p6-cdk-namer 1.3.44 → 1.3.46

package/node_modules/@aws-sdk/token-providers/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js

@@ -1,828 +0,0 @@
-'use strict';
-
-var utilStream = require('@smithy/util-stream');
-var schema = require('@smithy/core/schema');
-var serde = require('@smithy/core/serde');
-var protocolHttp = require('@smithy/protocol-http');
-var utilBase64 = require('@smithy/util-base64');
-var utilUtf8 = require('@smithy/util-utf8');
-
-const collectBody = async (streamBody = new Uint8Array(), context) => {
-    if (streamBody instanceof Uint8Array) {
-        return utilStream.Uint8ArrayBlobAdapter.mutate(streamBody);
-    }
-    if (!streamBody) {
-        return utilStream.Uint8ArrayBlobAdapter.mutate(new Uint8Array());
-    }
-    const fromContext = context.streamCollector(streamBody);
-    return utilStream.Uint8ArrayBlobAdapter.mutate(await fromContext);
-};
-
-function extendedEncodeURIComponent(str) {
-    return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
-        return "%" + c.charCodeAt(0).toString(16).toUpperCase();
-    });
-}
-
-class SerdeContext {
-    serdeContext;
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
-}
-
-class HttpProtocol extends SerdeContext {
-    options;
-    constructor(options) {
-        super();
-        this.options = options;
-    }
-    getRequestType() {
-        return protocolHttp.HttpRequest;
-    }
-    getResponseType() {
-        return protocolHttp.HttpResponse;
-    }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-        this.serializer.setSerdeContext(serdeContext);
-        this.deserializer.setSerdeContext(serdeContext);
-        if (this.getPayloadCodec()) {
-            this.getPayloadCodec().setSerdeContext(serdeContext);
-        }
-    }
-    updateServiceEndpoint(request, endpoint) {
-        if ("url" in endpoint) {
-            request.protocol = endpoint.url.protocol;
-            request.hostname = endpoint.url.hostname;
-            request.port = endpoint.url.port ? Number(endpoint.url.port) : undefined;
-            request.path = endpoint.url.pathname;
-            request.fragment = endpoint.url.hash || void 0;
-            request.username = endpoint.url.username || void 0;
-            request.password = endpoint.url.password || void 0;
-            if (!request.query) {
-                request.query = {};
-            }
-            for (const [k, v] of endpoint.url.searchParams.entries()) {
-                request.query[k] = v;
-            }
-            return request;
-        }
-        else {
-            request.protocol = endpoint.protocol;
-            request.hostname = endpoint.hostname;
-            request.port = endpoint.port ? Number(endpoint.port) : undefined;
-            request.path = endpoint.path;
-            request.query = {
-                ...endpoint.query,
-            };
-            return request;
-        }
-    }
-    setHostPrefix(request, operationSchema, input) {
-        const operationNs = schema.NormalizedSchema.of(operationSchema);
-        const inputNs = schema.NormalizedSchema.of(operationSchema.input);
-        if (operationNs.getMergedTraits().endpoint) {
-            let hostPrefix = operationNs.getMergedTraits().endpoint?.[0];
-            if (typeof hostPrefix === "string") {
-                const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel);
-                for (const [name] of hostLabelInputs) {
-                    const replacement = input[name];
-                    if (typeof replacement !== "string") {
-                        throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
-                    }
-                    hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
-                }
-                request.hostname = hostPrefix + request.hostname;
-            }
-        }
-    }
-    deserializeMetadata(output) {
-        return {
-            httpStatusCode: output.statusCode,
-            requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-            extendedRequestId: output.headers["x-amz-id-2"],
-            cfId: output.headers["x-amz-cf-id"],
-        };
-    }
-    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
-        const eventStreamSerde = await this.loadEventStreamCapability();
-        return eventStreamSerde.serializeEventStream({
-            eventStream,
-            requestSchema,
-            initialRequest,
-        });
-    }
-    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
-        const eventStreamSerde = await this.loadEventStreamCapability();
-        return eventStreamSerde.deserializeEventStream({
-            response,
-            responseSchema,
-            initialResponseContainer,
-        });
-    }
-    async loadEventStreamCapability() {
-        const { EventStreamSerde } = await import('@smithy/core/event-streams');
-        return new EventStreamSerde({
-            marshaller: this.getEventStreamMarshaller(),
-            serializer: this.serializer,
-            deserializer: this.deserializer,
-            serdeContext: this.serdeContext,
-            defaultContentType: this.getDefaultContentType(),
-        });
-    }
-    getDefaultContentType() {
-        throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
-    }
-    async deserializeHttpMessage(schema, context, response, arg4, arg5) {
-        return [];
-    }
-    getEventStreamMarshaller() {
-        const context = this.serdeContext;
-        if (!context.eventStreamMarshaller) {
-            throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
-        }
-        return context.eventStreamMarshaller;
-    }
-}
-
-class HttpBindingProtocol extends HttpProtocol {
-    async serializeRequest(operationSchema, _input, context) {
-        const input = {
-            ...(_input ?? {}),
-        };
-        const serializer = this.serializer;
-        const query = {};
-        const headers = {};
-        const endpoint = await context.endpoint();
-        const ns = schema.NormalizedSchema.of(operationSchema?.input);
-        const schema$1 = ns.getSchema();
-        let hasNonHttpBindingMember = false;
-        let payload;
-        const request = new protocolHttp.HttpRequest({
-            protocol: "",
-            hostname: "",
-            port: undefined,
-            path: "",
-            fragment: undefined,
-            query: query,
-            headers: headers,
-            body: undefined,
-        });
-        if (endpoint) {
-            this.updateServiceEndpoint(request, endpoint);
-            this.setHostPrefix(request, operationSchema, input);
-            const opTraits = schema.translateTraits(operationSchema.traits);
-            if (opTraits.http) {
-                request.method = opTraits.http[0];
-                const [path, search] = opTraits.http[1].split("?");
-                if (request.path == "/") {
-                    request.path = path;
-                }
-                else {
-                    request.path += path;
-                }
-                const traitSearchParams = new URLSearchParams(search ?? "");
-                Object.assign(query, Object.fromEntries(traitSearchParams));
-            }
-        }
-        for (const [memberName, memberNs] of ns.structIterator()) {
-            const memberTraits = memberNs.getMergedTraits() ?? {};
-            const inputMemberValue = input[memberName];
-            if (inputMemberValue == null) {
-                continue;
-            }
-            if (memberTraits.httpPayload) {
-                const isStreaming = memberNs.isStreaming();
-                if (isStreaming) {
-                    const isEventStream = memberNs.isStructSchema();
-                    if (isEventStream) {
-                        if (input[memberName]) {
-                            payload = await this.serializeEventStream({
-                                eventStream: input[memberName],
-                                requestSchema: ns,
-                            });
-                        }
-                    }
-                    else {
-                        payload = inputMemberValue;
-                    }
-                }
-                else {
-                    serializer.write(memberNs, inputMemberValue);
-                    payload = serializer.flush();
-                }
-                delete input[memberName];
-            }
-            else if (memberTraits.httpLabel) {
-                serializer.write(memberNs, inputMemberValue);
-                const replacement = serializer.flush();
-                if (request.path.includes(`{${memberName}+}`)) {
-                    request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/"));
-                }
-                else if (request.path.includes(`{${memberName}}`)) {
-                    request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement));
-                }
-                delete input[memberName];
-            }
-            else if (memberTraits.httpHeader) {
-                serializer.write(memberNs, inputMemberValue);
-                headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
-                delete input[memberName];
-            }
-            else if (typeof memberTraits.httpPrefixHeaders === "string") {
-                for (const [key, val] of Object.entries(inputMemberValue)) {
-                    const amalgam = memberTraits.httpPrefixHeaders + key;
-                    serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
-                    headers[amalgam.toLowerCase()] = serializer.flush();
-                }
-                delete input[memberName];
-            }
-            else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
-                this.serializeQuery(memberNs, inputMemberValue, query);
-                delete input[memberName];
-            }
-            else {
-                hasNonHttpBindingMember = true;
-            }
-        }
-        if (hasNonHttpBindingMember && input) {
-            serializer.write(schema$1, input);
-            payload = serializer.flush();
-        }
-        request.headers = headers;
-        request.query = query;
-        request.body = payload;
-        return request;
-    }
-    serializeQuery(ns, data, query) {
-        const serializer = this.serializer;
-        const traits = ns.getMergedTraits();
-        if (traits.httpQueryParams) {
-            for (const [key, val] of Object.entries(data)) {
-                if (!(key in query)) {
-                    const valueSchema = ns.getValueSchema();
-                    Object.assign(valueSchema.getMergedTraits(), {
-                        ...traits,
-                        httpQuery: key,
-                        httpQueryParams: undefined,
-                    });
-                    this.serializeQuery(valueSchema, val, query);
-                }
-            }
-            return;
-        }
-        if (ns.isListSchema()) {
-            const sparse = !!ns.getMergedTraits().sparse;
-            const buffer = [];
-            for (const item of data) {
-                serializer.write([ns.getValueSchema(), traits], item);
-                const serializable = serializer.flush();
-                if (sparse || serializable !== undefined) {
-                    buffer.push(serializable);
-                }
-            }
-            query[traits.httpQuery] = buffer;
-        }
-        else {
-            serializer.write([ns, traits], data);
-            query[traits.httpQuery] = serializer.flush();
-        }
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        const deserializer = this.deserializer;
-        const ns = schema.NormalizedSchema.of(operationSchema.output);
-        const dataObject = {};
-        if (response.statusCode >= 300) {
-            const bytes = await collectBody(response.body, context);
-            if (bytes.byteLength > 0) {
-                Object.assign(dataObject, await deserializer.read(15, bytes));
-            }
-            await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
-            throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
-        }
-        for (const header in response.headers) {
-            const value = response.headers[header];
-            delete response.headers[header];
-            response.headers[header.toLowerCase()] = value;
-        }
-        const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, dataObject);
-        if (nonHttpBindingMembers.length) {
-            const bytes = await collectBody(response.body, context);
-            if (bytes.byteLength > 0) {
-                const dataFromBody = await deserializer.read(ns, bytes);
-                for (const member of nonHttpBindingMembers) {
-                    dataObject[member] = dataFromBody[member];
-                }
-            }
-        }
-        dataObject.$metadata = this.deserializeMetadata(response);
-        return dataObject;
-    }
-    async deserializeHttpMessage(schema$1, context, response, arg4, arg5) {
-        let dataObject;
-        if (arg4 instanceof Set) {
-            dataObject = arg5;
-        }
-        else {
-            dataObject = arg4;
-        }
-        const deserializer = this.deserializer;
-        const ns = schema.NormalizedSchema.of(schema$1);
-        const nonHttpBindingMembers = [];
-        for (const [memberName, memberSchema] of ns.structIterator()) {
-            const memberTraits = memberSchema.getMemberTraits();
-            if (memberTraits.httpPayload) {
-                const isStreaming = memberSchema.isStreaming();
-                if (isStreaming) {
-                    const isEventStream = memberSchema.isStructSchema();
-                    if (isEventStream) {
-                        dataObject[memberName] = await this.deserializeEventStream({
-                            response,
-                            responseSchema: ns,
-                        });
-                    }
-                    else {
-                        dataObject[memberName] = utilStream.sdkStreamMixin(response.body);
-                    }
-                }
-                else if (response.body) {
-                    const bytes = await collectBody(response.body, context);
-                    if (bytes.byteLength > 0) {
-                        dataObject[memberName] = await deserializer.read(memberSchema, bytes);
-                    }
-                }
-            }
-            else if (memberTraits.httpHeader) {
-                const key = String(memberTraits.httpHeader).toLowerCase();
-                const value = response.headers[key];
-                if (null != value) {
-                    if (memberSchema.isListSchema()) {
-                        const headerListValueSchema = memberSchema.getValueSchema();
-                        headerListValueSchema.getMergedTraits().httpHeader = key;
-                        let sections;
-                        if (headerListValueSchema.isTimestampSchema() &&
-                            headerListValueSchema.getSchema() === 4) {
-                            sections = serde.splitEvery(value, ",", 2);
-                        }
-                        else {
-                            sections = serde.splitHeader(value);
-                        }
-                        const list = [];
-                        for (const section of sections) {
-                            list.push(await deserializer.read(headerListValueSchema, section.trim()));
-                        }
-                        dataObject[memberName] = list;
-                    }
-                    else {
-                        dataObject[memberName] = await deserializer.read(memberSchema, value);
-                    }
-                }
-            }
-            else if (memberTraits.httpPrefixHeaders !== undefined) {
-                dataObject[memberName] = {};
-                for (const [header, value] of Object.entries(response.headers)) {
-                    if (header.startsWith(memberTraits.httpPrefixHeaders)) {
-                        const valueSchema = memberSchema.getValueSchema();
-                        valueSchema.getMergedTraits().httpHeader = header;
-                        dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
-                    }
-                }
-            }
-            else if (memberTraits.httpResponseCode) {
-                dataObject[memberName] = response.statusCode;
-            }
-            else {
-                nonHttpBindingMembers.push(memberName);
-            }
-        }
-        return nonHttpBindingMembers;
-    }
-}
-
-class RpcProtocol extends HttpProtocol {
-    async serializeRequest(operationSchema, input, context) {
-        const serializer = this.serializer;
-        const query = {};
-        const headers = {};
-        const endpoint = await context.endpoint();
-        const ns = schema.NormalizedSchema.of(operationSchema?.input);
-        const schema$1 = ns.getSchema();
-        let payload;
-        const request = new protocolHttp.HttpRequest({
-            protocol: "",
-            hostname: "",
-            port: undefined,
-            path: "/",
-            fragment: undefined,
-            query: query,
-            headers: headers,
-            body: undefined,
-        });
-        if (endpoint) {
-            this.updateServiceEndpoint(request, endpoint);
-            this.setHostPrefix(request, operationSchema, input);
-        }
-        const _input = {
-            ...input,
-        };
-        if (input) {
-            const eventStreamMember = ns.getEventStreamMember();
-            if (eventStreamMember) {
-                if (_input[eventStreamMember]) {
-                    const initialRequest = {};
-                    for (const [memberName, memberSchema] of ns.structIterator()) {
-                        if (memberName !== eventStreamMember && _input[memberName]) {
-                            serializer.write(memberSchema, _input[memberName]);
-                            initialRequest[memberName] = serializer.flush();
-                        }
-                    }
-                    payload = await this.serializeEventStream({
-                        eventStream: _input[eventStreamMember],
-                        requestSchema: ns,
-                        initialRequest,
-                    });
-                }
-            }
-            else {
-                serializer.write(schema$1, _input);
-                payload = serializer.flush();
-            }
-        }
-        request.headers = headers;
-        request.query = query;
-        request.body = payload;
-        request.method = "POST";
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        const deserializer = this.deserializer;
-        const ns = schema.NormalizedSchema.of(operationSchema.output);
-        const dataObject = {};
-        if (response.statusCode >= 300) {
-            const bytes = await collectBody(response.body, context);
-            if (bytes.byteLength > 0) {
-                Object.assign(dataObject, await deserializer.read(15, bytes));
-            }
-            await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
-            throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
-        }
-        for (const header in response.headers) {
-            const value = response.headers[header];
-            delete response.headers[header];
-            response.headers[header.toLowerCase()] = value;
-        }
-        const eventStreamMember = ns.getEventStreamMember();
-        if (eventStreamMember) {
-            dataObject[eventStreamMember] = await this.deserializeEventStream({
-                response,
-                responseSchema: ns,
-                initialResponseContainer: dataObject,
-            });
-        }
-        else {
-            const bytes = await collectBody(response.body, context);
-            if (bytes.byteLength > 0) {
-                Object.assign(dataObject, await deserializer.read(ns, bytes));
-            }
-        }
-        dataObject.$metadata = this.deserializeMetadata(response);
-        return dataObject;
-    }
-}
-
-const resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
-    if (input != null && input[memberName] !== undefined) {
-        const labelValue = labelValueProvider();
-        if (labelValue.length <= 0) {
-            throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
-        }
-        resolvedPath = resolvedPath.replace(uriLabel, isGreedyLabel
-            ? labelValue
-                .split("/")
-                .map((segment) => extendedEncodeURIComponent(segment))
-                .join("/")
-            : extendedEncodeURIComponent(labelValue));
-    }
-    else {
-        throw new Error("No value provided for input HTTP label: " + memberName + ".");
-    }
-    return resolvedPath;
-};
-
-function requestBuilder(input, context) {
-    return new RequestBuilder(input, context);
-}
-class RequestBuilder {
-    input;
-    context;
-    query = {};
-    method = "";
-    headers = {};
-    path = "";
-    body = null;
-    hostname = "";
-    resolvePathStack = [];
-    constructor(input, context) {
-        this.input = input;
-        this.context = context;
-    }
-    async build() {
-        const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
-        this.path = basePath;
-        for (const resolvePath of this.resolvePathStack) {
-            resolvePath(this.path);
-        }
-        return new protocolHttp.HttpRequest({
-            protocol,
-            hostname: this.hostname || hostname,
-            port,
-            method: this.method,
-            path: this.path,
-            query: this.query,
-            body: this.body,
-            headers: this.headers,
-        });
-    }
-    hn(hostname) {
-        this.hostname = hostname;
-        return this;
-    }
-    bp(uriLabel) {
-        this.resolvePathStack.push((basePath) => {
-            this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
-        });
-        return this;
-    }
-    p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
-        this.resolvePathStack.push((path) => {
-            this.path = resolvedPath(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
-        });
-        return this;
-    }
-    h(headers) {
-        this.headers = headers;
-        return this;
-    }
-    q(query) {
-        this.query = query;
-        return this;
-    }
-    b(body) {
-        this.body = body;
-        return this;
-    }
-    m(method) {
-        this.method = method;
-        return this;
-    }
-}
-
-function determineTimestampFormat(ns, settings) {
-    if (settings.timestampFormat.useTrait) {
-        if (ns.isTimestampSchema() &&
-            (ns.getSchema() === 5 ||
-                ns.getSchema() === 6 ||
-                ns.getSchema() === 7)) {
-            return ns.getSchema();
-        }
-    }
-    const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits();
-    const bindingFormat = settings.httpBindings
-        ? typeof httpPrefixHeaders === "string" || Boolean(httpHeader)
-            ? 6
-            : Boolean(httpQuery) || Boolean(httpLabel)
-                ? 5
-                : undefined
-        : undefined;
-    return bindingFormat ?? settings.timestampFormat.default;
-}
-
-class FromStringShapeDeserializer extends SerdeContext {
-    settings;
-    constructor(settings) {
-        super();
-        this.settings = settings;
-    }
-    read(_schema, data) {
-        const ns = schema.NormalizedSchema.of(_schema);
-        if (ns.isListSchema()) {
-            return serde.splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
-        }
-        if (ns.isBlobSchema()) {
-            return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(data);
-        }
-        if (ns.isTimestampSchema()) {
-            const format = determineTimestampFormat(ns, this.settings);
-            switch (format) {
-                case 5:
-                    return serde._parseRfc3339DateTimeWithOffset(data);
-                case 6:
-                    return serde._parseRfc7231DateTime(data);
-                case 7:
-                    return serde._parseEpochTimestamp(data);
-                default:
-                    console.warn("Missing timestamp format, parsing value with Date constructor:", data);
-                    return new Date(data);
-            }
-        }
-        if (ns.isStringSchema()) {
-            const mediaType = ns.getMergedTraits().mediaType;
-            let intermediateValue = data;
-            if (mediaType) {
-                if (ns.getMergedTraits().httpHeader) {
-                    intermediateValue = this.base64ToUtf8(intermediateValue);
-                }
-                const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
-                if (isJson) {
-                    intermediateValue = serde.LazyJsonString.from(intermediateValue);
-                }
-                return intermediateValue;
-            }
-        }
-        if (ns.isNumericSchema()) {
-            return Number(data);
-        }
-        if (ns.isBigIntegerSchema()) {
-            return BigInt(data);
-        }
-        if (ns.isBigDecimalSchema()) {
-            return new serde.NumericValue(data, "bigDecimal");
-        }
-        if (ns.isBooleanSchema()) {
-            return String(data).toLowerCase() === "true";
-        }
-        return data;
-    }
-    base64ToUtf8(base64String) {
-        return (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)((this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(base64String));
-    }
-}
-
-class HttpInterceptingShapeDeserializer extends SerdeContext {
-    codecDeserializer;
-    stringDeserializer;
-    constructor(codecDeserializer, codecSettings) {
-        super();
-        this.codecDeserializer = codecDeserializer;
-        this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
-    }
-    setSerdeContext(serdeContext) {
-        this.stringDeserializer.setSerdeContext(serdeContext);
-        this.codecDeserializer.setSerdeContext(serdeContext);
-        this.serdeContext = serdeContext;
-    }
-    read(schema$1, data) {
-        const ns = schema.NormalizedSchema.of(schema$1);
-        const traits = ns.getMergedTraits();
-        const toString = this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8;
-        if (traits.httpHeader || traits.httpResponseCode) {
-            return this.stringDeserializer.read(ns, toString(data));
-        }
-        if (traits.httpPayload) {
-            if (ns.isBlobSchema()) {
-                const toBytes = this.serdeContext?.utf8Decoder ?? utilUtf8.fromUtf8;
-                if (typeof data === "string") {
-                    return toBytes(data);
-                }
-                return data;
-            }
-            else if (ns.isStringSchema()) {
-                if ("byteLength" in data) {
-                    return toString(data);
-                }
-                return data;
-            }
-        }
-        return this.codecDeserializer.read(ns, data);
-    }
-}
-
-class ToStringShapeSerializer extends SerdeContext {
-    settings;
-    stringBuffer = "";
-    constructor(settings) {
-        super();
-        this.settings = settings;
-    }
-    write(schema$1, value) {
-        const ns = schema.NormalizedSchema.of(schema$1);
-        switch (typeof value) {
-            case "object":
-                if (value === null) {
-                    this.stringBuffer = "null";
-                    return;
-                }
-                if (ns.isTimestampSchema()) {
-                    if (!(value instanceof Date)) {
-                        throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns.getName(true)}`);
-                    }
-                    const format = determineTimestampFormat(ns, this.settings);
-                    switch (format) {
-                        case 5:
-                            this.stringBuffer = value.toISOString().replace(".000Z", "Z");
-                            break;
-                        case 6:
-                            this.stringBuffer = serde.dateToUtcString(value);
-                            break;
-                        case 7:
-                            this.stringBuffer = String(value.getTime() / 1000);
-                            break;
-                        default:
-                            console.warn("Missing timestamp format, using epoch seconds", value);
-                            this.stringBuffer = String(value.getTime() / 1000);
-                    }
-                    return;
-                }
-                if (ns.isBlobSchema() && "byteLength" in value) {
-                    this.stringBuffer = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value);
-                    return;
-                }
-                if (ns.isListSchema() && Array.isArray(value)) {
-                    let buffer = "";
-                    for (const item of value) {
-                        this.write([ns.getValueSchema(), ns.getMergedTraits()], item);
-                        const headerItem = this.flush();
-                        const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : serde.quoteHeader(headerItem);
-                        if (buffer !== "") {
-                            buffer += ", ";
-                        }
-                        buffer += serialized;
-                    }
-                    this.stringBuffer = buffer;
-                    return;
-                }
-                this.stringBuffer = JSON.stringify(value, null, 2);
-                break;
-            case "string":
-                const mediaType = ns.getMergedTraits().mediaType;
-                let intermediateValue = value;
-                if (mediaType) {
-                    const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
-                    if (isJson) {
-                        intermediateValue = serde.LazyJsonString.from(intermediateValue);
-                    }
-                    if (ns.getMergedTraits().httpHeader) {
-                        this.stringBuffer = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(intermediateValue.toString());
-                        return;
-                    }
-                }
-                this.stringBuffer = value;
-                break;
-            default:
-                this.stringBuffer = String(value);
-        }
-    }
-    flush() {
-        const buffer = this.stringBuffer;
-        this.stringBuffer = "";
-        return buffer;
-    }
-}
-
-class HttpInterceptingShapeSerializer {
-    codecSerializer;
-    stringSerializer;
-    buffer;
-    constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
-        this.codecSerializer = codecSerializer;
-        this.stringSerializer = stringSerializer;
-    }
-    setSerdeContext(serdeContext) {
-        this.codecSerializer.setSerdeContext(serdeContext);
-        this.stringSerializer.setSerdeContext(serdeContext);
-    }
-    write(schema$1, value) {
-        const ns = schema.NormalizedSchema.of(schema$1);
-        const traits = ns.getMergedTraits();
-        if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
-            this.stringSerializer.write(ns, value);
-            this.buffer = this.stringSerializer.flush();
-            return;
-        }
-        return this.codecSerializer.write(ns, value);
-    }
-    flush() {
-        if (this.buffer !== undefined) {
-            const buffer = this.buffer;
-            this.buffer = undefined;
-            return buffer;
-        }
-        return this.codecSerializer.flush();
-    }
-}
-
-exports.FromStringShapeDeserializer = FromStringShapeDeserializer;
-exports.HttpBindingProtocol = HttpBindingProtocol;
-exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer;
-exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer;
-exports.HttpProtocol = HttpProtocol;
-exports.RequestBuilder = RequestBuilder;
-exports.RpcProtocol = RpcProtocol;
-exports.SerdeContext = SerdeContext;
-exports.ToStringShapeSerializer = ToStringShapeSerializer;
-exports.collectBody = collectBody;
-exports.determineTimestampFormat = determineTimestampFormat;
-exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
-exports.requestBuilder = requestBuilder;
-exports.resolvedPath = resolvedPath;