lambda-live-debugger 1.8.2 → 1.8.4

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -0,0 +1,171 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { splitEvery, splitHeader } from "@smithy/core/serde";
+import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
+import { sdkStreamMixin } from "@smithy/util-stream";
+import { collectBody } from "./collect-stream-body";
+export class HttpProtocol {
+    constructor(options) {
+        this.options = options;
+    }
+    getRequestType() {
+        return HttpRequest;
+    }
+    getResponseType() {
+        return 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;
+            for (const [k, v] of endpoint.url.searchParams.entries()) {
+                if (!request.query) {
+                    request.query = {};
+                }
+                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 = NormalizedSchema.of(operationSchema);
+        const inputNs = 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 deserializeHttpMessage(schema, context, response, arg4, arg5) {
+        let dataObject;
+        if (arg4 instanceof Set) {
+            dataObject = arg5;
+        }
+        else {
+            dataObject = arg4;
+        }
+        const deserializer = this.deserializer;
+        const ns = NormalizedSchema.of(schema);
+        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) {
+                        const context = this.serdeContext;
+                        if (!context.eventStreamMarshaller) {
+                            throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
+                        }
+                        const memberSchemas = memberSchema.getMemberSchemas();
+                        dataObject[memberName] = context.eventStreamMarshaller.deserialize(response.body, async (event) => {
+                            const unionMember = Object.keys(event).find((key) => {
+                                return key !== "__type";
+                            }) ?? "";
+                            if (unionMember in memberSchemas) {
+                                const eventStreamSchema = memberSchemas[unionMember];
+                                return {
+                                    [unionMember]: await deserializer.read(eventStreamSchema, event[unionMember].body),
+                                };
+                            }
+                            else {
+                                return {
+                                    $unknown: event,
+                                };
+                            }
+                        });
+                    }
+                    else {
+                        dataObject[memberName] = 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();
+                        let sections;
+                        if (headerListValueSchema.isTimestampSchema() &&
+                            headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
+                            sections = splitEvery(value, ",", 2);
+                        }
+                        else {
+                            sections = splitHeader(value);
+                        }
+                        const list = [];
+                        for (const section of sections) {
+                            list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], 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)) {
+                        dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read([memberSchema.getValueSchema(), { httpHeader: header }], value);
+                    }
+                }
+            }
+            else if (memberTraits.httpResponseCode) {
+                dataObject[memberName] = response.statusCode;
+            }
+            else {
+                nonHttpBindingMembers.push(memberName);
+            }
+        }
+        return nonHttpBindingMembers;
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -0,0 +1,68 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { HttpRequest } from "@smithy/protocol-http";
+import { collectBody } from "./collect-stream-body";
+import { HttpProtocol } from "./HttpProtocol";
+export class RpcProtocol extends HttpProtocol {
+    async serializeRequest(operationSchema, input, context) {
+        const serializer = this.serializer;
+        const query = {};
+        const headers = {};
+        const endpoint = await context.endpoint();
+        const ns = NormalizedSchema.of(operationSchema?.input);
+        const schema = ns.getSchema();
+        let payload;
+        const request = new 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) {
+            serializer.write(schema, _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 = 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(SCHEMA.DOCUMENT, 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 bytes = await collectBody(response.body, context);
+        if (bytes.byteLength > 0) {
+            Object.assign(dataObject, await deserializer.read(ns, bytes));
+        }
+        const output = {
+            $metadata: this.deserializeMetadata(response),
+            ...dataObject,
+        };
+        return output;
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/index.js

@@ -1,4 +1,11 @@
 export * from "./collect-stream-body";
 export * from "./extended-encode-uri-component";
+export * from "./HttpBindingProtocol";
+export * from "./RpcProtocol";
 export * from "./requestBuilder";
 export * from "./resolve-path";
+export * from "./serde/FromStringShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeSerializer";
+export * from "./serde/ToStringShapeSerializer";
+export * from "./serde/determineTimestampFormat";

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js

@@ -0,0 +1,64 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, splitHeader, } from "@smithy/core/serde";
+import { fromBase64 } from "@smithy/util-base64";
+import { toUtf8 } from "@smithy/util-utf8";
+import { determineTimestampFormat } from "./determineTimestampFormat";
+export class FromStringShapeDeserializer {
+    constructor(settings) {
+        this.settings = settings;
+    }
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+    read(_schema, data) {
+        const ns = NormalizedSchema.of(_schema);
+        if (ns.isListSchema()) {
+            return splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
+        }
+        if (ns.isBlobSchema()) {
+            return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
+        }
+        if (ns.isTimestampSchema()) {
+            const format = determineTimestampFormat(ns, this.settings);
+            switch (format) {
+                case SCHEMA.TIMESTAMP_DATE_TIME:
+                    return parseRfc3339DateTimeWithOffset(data);
+                case SCHEMA.TIMESTAMP_HTTP_DATE:
+                    return parseRfc7231DateTime(data);
+                case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                    return 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 = LazyJsonString.from(intermediateValue);
+                }
+                return intermediateValue;
+            }
+        }
+        switch (true) {
+            case ns.isNumericSchema():
+                return Number(data);
+            case ns.isBigIntegerSchema():
+                return BigInt(data);
+            case ns.isBigDecimalSchema():
+                return new NumericValue(data, "bigDecimal");
+            case ns.isBooleanSchema():
+                return String(data).toLowerCase() === "true";
+        }
+        return data;
+    }
+    base64ToUtf8(base64String) {
+        return (this.serdeContext?.utf8Encoder ?? toUtf8)((this.serdeContext?.base64Decoder ?? fromBase64)(base64String));
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js

@@ -0,0 +1,38 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { FromStringShapeDeserializer } from "./FromStringShapeDeserializer";
+export class HttpInterceptingShapeDeserializer {
+    constructor(codecDeserializer, codecSettings) {
+        this.codecDeserializer = codecDeserializer;
+        this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
+    }
+    setSerdeContext(serdeContext) {
+        this.stringDeserializer.setSerdeContext(serdeContext);
+        this.codecDeserializer.setSerdeContext(serdeContext);
+        this.serdeContext = serdeContext;
+    }
+    read(schema, data) {
+        const ns = NormalizedSchema.of(schema);
+        const traits = ns.getMergedTraits();
+        const toString = this.serdeContext?.utf8Encoder ?? toUtf8;
+        if (traits.httpHeader || traits.httpResponseCode) {
+            return this.stringDeserializer.read(ns, toString(data));
+        }
+        if (traits.httpPayload) {
+            if (ns.isBlobSchema()) {
+                const toBytes = this.serdeContext?.utf8Decoder ?? 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);
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeSerializer.js

@@ -0,0 +1,30 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { ToStringShapeSerializer } from "./ToStringShapeSerializer";
+export class HttpInterceptingShapeSerializer {
+    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, value) {
+        const ns = NormalizedSchema.of(schema);
+        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();
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/serde/ToStringShapeSerializer.js

@@ -0,0 +1,87 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { dateToUtcString, LazyJsonString, quoteHeader } from "@smithy/core/serde";
+import { toBase64 } from "@smithy/util-base64";
+import { determineTimestampFormat } from "./determineTimestampFormat";
+export class ToStringShapeSerializer {
+    constructor(settings) {
+        this.settings = settings;
+        this.stringBuffer = "";
+        this.serdeContext = undefined;
+    }
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+    write(schema, value) {
+        const ns = NormalizedSchema.of(schema);
+        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 SCHEMA.TIMESTAMP_DATE_TIME:
+                            this.stringBuffer = value.toISOString().replace(".000Z", "Z");
+                            break;
+                        case SCHEMA.TIMESTAMP_HTTP_DATE:
+                            this.stringBuffer = dateToUtcString(value);
+                            break;
+                        case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                            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 ?? 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 : 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 = LazyJsonString.from(intermediateValue);
+                    }
+                    if (ns.getMergedTraits().httpHeader) {
+                        this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(intermediateValue.toString());
+                        return;
+                    }
+                }
+                this.stringBuffer = value;
+                break;
+            default:
+                this.stringBuffer = String(value);
+        }
+    }
+    flush() {
+        const buffer = this.stringBuffer;
+        this.stringBuffer = "";
+        return buffer;
+    }
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/protocols/serde/determineTimestampFormat.js

@@ -0,0 +1,20 @@
+import { SCHEMA } from "@smithy/core/schema";
+export function determineTimestampFormat(ns, settings) {
+    if (settings.timestampFormat.useTrait) {
+        if (ns.isTimestampSchema() &&
+            (ns.getSchema() === SCHEMA.TIMESTAMP_DATE_TIME ||
+                ns.getSchema() === SCHEMA.TIMESTAMP_HTTP_DATE ||
+                ns.getSchema() === SCHEMA.TIMESTAMP_EPOCH_SECONDS)) {
+            return ns.getSchema();
+        }
+    }
+    const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits();
+    const bindingFormat = settings.httpBindings
+        ? typeof httpPrefixHeaders === "string" || Boolean(httpHeader)
+            ? SCHEMA.TIMESTAMP_HTTP_DATE
+            : Boolean(httpQuery) || Boolean(httpLabel)
+                ? SCHEMA.TIMESTAMP_DATE_TIME
+                : undefined
+        : undefined;
+    return bindingFormat ?? settings.timestampFormat.default;
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js

@@ -0,0 +1,49 @@
+export class TypeRegistry {
+    constructor(namespace, schemas = new Map()) {
+        this.namespace = namespace;
+        this.schemas = schemas;
+    }
+    static for(namespace) {
+        if (!TypeRegistry.registries.has(namespace)) {
+            TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
+        }
+        return TypeRegistry.registries.get(namespace);
+    }
+    register(shapeId, schema) {
+        const qualifiedName = this.normalizeShapeId(shapeId);
+        const registry = TypeRegistry.for(this.getNamespace(shapeId));
+        registry.schemas.set(qualifiedName, schema);
+    }
+    getSchema(shapeId) {
+        const id = this.normalizeShapeId(shapeId);
+        if (!this.schemas.has(id)) {
+            throw new Error(`@smithy/core/schema - schema not found for ${id}`);
+        }
+        return this.schemas.get(id);
+    }
+    getBaseException() {
+        for (const [id, schema] of this.schemas.entries()) {
+            if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+                return schema;
+            }
+        }
+        return undefined;
+    }
+    find(predicate) {
+        return [...this.schemas.values()].find(predicate);
+    }
+    destroy() {
+        TypeRegistry.registries.delete(this.namespace);
+        this.schemas.clear();
+    }
+    normalizeShapeId(shapeId) {
+        if (shapeId.includes("#")) {
+            return shapeId;
+        }
+        return this.namespace + "#" + shapeId;
+    }
+    getNamespace(shapeId) {
+        return this.normalizeShapeId(shapeId).split("#")[0];
+    }
+}
+TypeRegistry.registries = new Map();

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/deref.js

@@ -0,0 +1,6 @@
+export const deref = (schemaRef) => {
+    if (typeof schemaRef === "function") {
+        return schemaRef();
+    }
+    return schemaRef;
+};

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/index.js

@@ -0,0 +1,12 @@
+export * from "./deref";
+export * from "./middleware/getSchemaSerdePlugin";
+export * from "./schemas/ListSchema";
+export * from "./schemas/MapSchema";
+export * from "./schemas/OperationSchema";
+export * from "./schemas/ErrorSchema";
+export * from "./schemas/NormalizedSchema";
+export * from "./schemas/Schema";
+export * from "./schemas/SimpleSchema";
+export * from "./schemas/StructureSchema";
+export * from "./schemas/sentinels";
+export * from "./TypeRegistry";

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js

@@ -0,0 +1,23 @@
+import { schemaDeserializationMiddleware } from "./schemaDeserializationMiddleware";
+import { schemaSerializationMiddleware } from "./schemaSerializationMiddleware";
+export const deserializerMiddlewareOption = {
+    name: "deserializerMiddleware",
+    step: "deserialize",
+    tags: ["DESERIALIZER"],
+    override: true,
+};
+export const serializerMiddlewareOption = {
+    name: "serializerMiddleware",
+    step: "serialize",
+    tags: ["SERIALIZER"],
+    override: true,
+};
+export function getSchemaSerdePlugin(config) {
+    return {
+        applyToStack: (commandStack) => {
+            commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+            commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+            config.protocol.setSerdeContext(config);
+        },
+    };
+}

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schema-middleware-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js

@@ -0,0 +1,60 @@
+import { HttpResponse } from "@smithy/protocol-http";
+import { getSmithyContext } from "@smithy/util-middleware";
+export const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+    const { response } = await next(args);
+    const { operationSchema } = getSmithyContext(context);
+    try {
+        const parsed = await config.protocol.deserializeResponse(operationSchema, {
+            ...config,
+            ...context,
+        }, response);
+        return {
+            response,
+            output: parsed,
+        };
+    }
+    catch (error) {
+        Object.defineProperty(error, "$response", {
+            value: response,
+        });
+        if (!("$metadata" in error)) {
+            const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+            try {
+                error.message += "\n  " + hint;
+            }
+            catch (e) {
+                if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+                    console.warn(hint);
+                }
+                else {
+                    context.logger?.warn?.(hint);
+                }
+            }
+            if (typeof error.$responseBodyText !== "undefined") {
+                if (error.$response) {
+                    error.$response.body = error.$responseBodyText;
+                }
+            }
+            try {
+                if (HttpResponse.isInstance(response)) {
+                    const { headers = {} } = response;
+                    const headerEntries = Object.entries(headers);
+                    error.$metadata = {
+                        httpStatusCode: response.statusCode,
+                        requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+                        extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+                        cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries),
+                    };
+                }
+            }
+            catch (e) {
+            }
+        }
+        throw error;
+    }
+};
+const findHeader = (pattern, headers) => {
+    return (headers.find(([k]) => {
+        return k.match(pattern);
+    }) || [void 0, void 1])[1];
+};

package/node_modules/@aws-sdk/client-cognito-identity/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js

@@ -0,0 +1,16 @@
+import { getSmithyContext } from "@smithy/util-middleware";
+export const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+    const { operationSchema } = getSmithyContext(context);
+    const endpoint = context.endpointV2?.url && config.urlParser
+        ? async () => config.urlParser(context.endpointV2.url)
+        : config.endpoint;
+    const request = await config.protocol.serializeRequest(operationSchema, args.input, {
+        ...config,
+        ...context,
+        endpoint,
+    });
+    return next({
+        ...args,
+        request,
+    });
+};