@cdk8s/awscdk-resolver 0.0.348 → 0.0.350

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ProtocolLib.js

@@ -0,0 +1,94 @@
+import { TypeRegistry } from "@smithy/core/schema";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+export class ProtocolLib {
+    calculateContentLength(body, serdeContext) {
+        const bodyLengthCalculator = serdeContext?.bodyLengthChecker ?? calculateBodyLength;
+        return String(bodyLengthCalculator(body));
+    }
+    resolveRestContentType(defaultContentType, inputSchema) {
+        const members = inputSchema.getMemberSchemas();
+        const httpPayloadMember = Object.values(members).find((m) => {
+            return !!m.getMergedTraits().httpPayload;
+        });
+        if (httpPayloadMember) {
+            const mediaType = httpPayloadMember.getMergedTraits().mediaType;
+            if (mediaType) {
+                return mediaType;
+            }
+            else if (httpPayloadMember.isStringSchema()) {
+                return "text/plain";
+            }
+            else if (httpPayloadMember.isBlobSchema()) {
+                return "application/octet-stream";
+            }
+            else {
+                return defaultContentType;
+            }
+        }
+        else if (!inputSchema.isUnitSchema()) {
+            const hasBody = Object.values(members).find((m) => {
+                const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
+                return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && httpPrefixHeaders === void 0;
+            });
+            if (hasBody) {
+                return defaultContentType;
+            }
+        }
+    }
+    async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) {
+        let namespace = defaultNamespace;
+        let errorName = errorIdentifier;
+        if (errorIdentifier.includes("#")) {
+            [namespace, errorName] = errorIdentifier.split("#");
+        }
+        const errorMetadata = {
+            $metadata: metadata,
+            $response: response,
+            $fault: response.statusCode < 500 ? "client" : "server",
+        };
+        const registry = TypeRegistry.for(namespace);
+        try {
+            const errorSchema = getErrorSchema?.(registry, errorName) ?? registry.getSchema(errorIdentifier);
+            return { errorSchema, errorMetadata };
+        }
+        catch (e) {
+            if (dataObject.Message) {
+                dataObject.message = dataObject.Message;
+            }
+            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = baseExceptionSchema.ctor;
+                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+            }
+            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
+        }
+    }
+    setQueryCompatError(output, response) {
+        const queryErrorHeader = response.headers?.["x-amzn-query-error"];
+        if (output !== undefined && queryErrorHeader != null) {
+            const [Code, Type] = queryErrorHeader.split(";");
+            const entries = Object.entries(output);
+            const Error = {
+                Code,
+                Type,
+            };
+            Object.assign(output, Error);
+            for (const [k, v] of entries) {
+                Error[k] = v;
+            }
+            delete Error.__type;
+            output.Error = Error;
+        }
+    }
+    queryCompatOutput(queryCompatErrorData, errorData) {
+        if (queryCompatErrorData.Error) {
+            errorData.Error = queryCompatErrorData.Error;
+        }
+        if (queryCompatErrorData.Type) {
+            errorData.Type = queryCompatErrorData.Type;
+        }
+        if (queryCompatErrorData.Code) {
+            errorData.Code = queryCompatErrorData.Code;
+        }
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/cbor/AwsSmithyRpcV2CborProtocol.js

@@ -0,0 +1,39 @@
+import { loadSmithyRpcV2CborErrorCode, SmithyRpcV2CborProtocol } from "@smithy/core/cbor";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
+export class AwsSmithyRpcV2CborProtocol extends SmithyRpcV2CborProtocol {
+    awsQueryCompatible;
+    mixin = new ProtocolLib();
+    constructor({ defaultNamespace, awsQueryCompatible, }) {
+        super({ defaultNamespace });
+        this.awsQueryCompatible = !!awsQueryCompatible;
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        if (this.awsQueryCompatible) {
+            request.headers["x-amzn-query-mode"] = "true";
+        }
+        return request;
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        if (this.awsQueryCompatible) {
+            this.mixin.setQueryCompatError(dataObject, response);
+        }
+        const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorName, this.options.defaultNamespace, response, dataObject, metadata);
+        const ns = NormalizedSchema.of(errorSchema);
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new errorSchema.ctor(message);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            output[name] = this.deserializer.readValue(member, dataObject[name]);
+        }
+        if (this.awsQueryCompatible) {
+            this.mixin.queryCompatOutput(dataObject, output);
+        }
+        throw Object.assign(exception, errorMetadata, {
+            $fault: ns.getMergedTraits().error,
+            message,
+        }, output);
+    }
+}

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js

@@ -1,2 +1,3 @@
 import { collectBody } from "@smithy/smithy-client";
-export const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+import { toUtf8 } from "@smithy/util-utf8";
+export const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/index.js

@@ -1,3 +1,4 @@
+export * from "./cbor/AwsSmithyRpcV2CborProtocol";
 export * from "./coercing-serializers";
 export * from "./json/AwsJson1_0Protocol";
 export * from "./json/AwsJson1_1Protocol";

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJson1_0Protocol.js

@@ -1,9 +1,10 @@
 import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
 export class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
-    constructor({ defaultNamespace, serviceTarget }) {
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) {
         super({
             defaultNamespace,
             serviceTarget,
+            awsQueryCompatible,
         });
     }
     getShapeId() {

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJson1_1Protocol.js

@@ -1,9 +1,10 @@
 import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
 export class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
-    constructor({ defaultNamespace, serviceTarget }) {
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) {
         super({
             defaultNamespace,
             serviceTarget,
+            awsQueryCompatible,
         });
     }
     getShapeId() {

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsJsonRpcProtocol.js

@@ -1,6 +1,6 @@
 import { RpcProtocol } from "@smithy/core/protocols";
-import { deref, NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { deref, NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
 import { JsonCodec } from "./JsonCodec";
 import { loadRestJsonErrorCode } from "./parseJsonBody";
 export class AwsJsonRpcProtocol extends RpcProtocol {
@@ -8,7 +8,9 @@ export class AwsJsonRpcProtocol extends RpcProtocol {
     deserializer;
     serviceTarget;
     codec;
-    constructor({ defaultNamespace, serviceTarget }) {
+    mixin = new ProtocolLib();
+    awsQueryCompatible;
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) {
         super({
             defaultNamespace,
         });
@@ -22,6 +24,7 @@ export class AwsJsonRpcProtocol extends RpcProtocol {
         });
         this.serializer = this.codec.createSerializer();
         this.deserializer = this.codec.createDeserializer();
+        this.awsQueryCompatible = !!awsQueryCompatible;
     }
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
@@ -32,11 +35,14 @@ export class AwsJsonRpcProtocol extends RpcProtocol {
             "content-type": `application/x-amz-json-${this.getJsonRpcVersion()}`,
             "x-amz-target": `${this.serviceTarget}.${NormalizedSchema.of(operationSchema).getName()}`,
         });
+        if (this.awsQueryCompatible) {
+            request.headers["x-amzn-query-mode"] = "true";
+        }
         if (deref(operationSchema.input) === "unit" || !request.body) {
             request.body = "{}";
         }
         try {
-            request.headers["content-length"] = String(calculateBodyLength(request.body));
+            request.headers["content-length"] = this.mixin.calculateContentLength(request.body, this.serdeContext);
         }
         catch (e) { }
         return request;
@@ -45,42 +51,22 @@ export class AwsJsonRpcProtocol extends RpcProtocol {
         return this.codec;
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
-        const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        let errorName = errorIdentifier;
-        if (errorIdentifier.includes("#")) {
-            [namespace, errorName] = errorIdentifier.split("#");
-        }
-        const errorMetadata = {
-            $metadata: metadata,
-            $response: response,
-            $fault: response.statusCode <= 500 ? "client" : "server",
-        };
-        const registry = TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.getSchema(errorIdentifier);
-        }
-        catch (e) {
-            if (dataObject.Message) {
-                dataObject.message = dataObject.Message;
-            }
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
-                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
-            }
-            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
+        if (this.awsQueryCompatible) {
+            this.mixin.setQueryCompatError(dataObject, response);
         }
+        const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
         const exception = new errorSchema.ctor(message);
-        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             const target = member.getMergedTraits().jsonName ?? name;
             output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]);
         }
+        if (this.awsQueryCompatible) {
+            this.mixin.queryCompatOutput(dataObject, output);
+        }
         throw Object.assign(exception, errorMetadata, {
             $fault: ns.getMergedTraits().error,
             message,

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/AwsRestJsonProtocol.js

@@ -1,12 +1,13 @@
 import { HttpBindingProtocol, HttpInterceptingShapeDeserializer, HttpInterceptingShapeSerializer, } from "@smithy/core/protocols";
-import { NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
 import { JsonCodec } from "./JsonCodec";
 import { loadRestJsonErrorCode } from "./parseJsonBody";
 export class AwsRestJsonProtocol extends HttpBindingProtocol {
     serializer;
     deserializer;
     codec;
+    mixin = new ProtocolLib();
     constructor({ defaultNamespace }) {
         super({
             defaultNamespace,
@@ -36,34 +37,10 @@ export class AwsRestJsonProtocol extends HttpBindingProtocol {
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
         const inputSchema = NormalizedSchema.of(operationSchema.input);
-        const members = inputSchema.getMemberSchemas();
         if (!request.headers["content-type"]) {
-            const httpPayloadMember = Object.values(members).find((m) => {
-                return !!m.getMergedTraits().httpPayload;
-            });
-            if (httpPayloadMember) {
-                const mediaType = httpPayloadMember.getMergedTraits().mediaType;
-                if (mediaType) {
-                    request.headers["content-type"] = mediaType;
-                }
-                else if (httpPayloadMember.isStringSchema()) {
-                    request.headers["content-type"] = "text/plain";
-                }
-                else if (httpPayloadMember.isBlobSchema()) {
-                    request.headers["content-type"] = "application/octet-stream";
-                }
-                else {
-                    request.headers["content-type"] = this.getDefaultContentType();
-                }
-            }
-            else if (!inputSchema.isUnitSchema()) {
-                const hasBody = Object.values(members).find((m) => {
-                    const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
-                    return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && httpPrefixHeaders === void 0;
-                });
-                if (hasBody) {
-                    request.headers["content-type"] = this.getDefaultContentType();
-                }
+            const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
+            if (contentType) {
+                request.headers["content-type"] = contentType;
             }
         }
         if (request.headers["content-type"] && !request.body) {
@@ -71,7 +48,7 @@ export class AwsRestJsonProtocol extends HttpBindingProtocol {
         }
         if (request.body) {
             try {
-                request.headers["content-length"] = String(calculateBodyLength(request.body));
+                request.headers["content-length"] = this.mixin.calculateContentLength(request.body, this.serdeContext);
             }
             catch (e) { }
         }
@@ -79,32 +56,7 @@ export class AwsRestJsonProtocol extends HttpBindingProtocol {
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        let errorName = errorIdentifier;
-        if (errorIdentifier.includes("#")) {
-            [namespace, errorName] = errorIdentifier.split("#");
-        }
-        const errorMetadata = {
-            $metadata: metadata,
-            $response: response,
-            $fault: response.statusCode <= 500 ? "client" : "server",
-        };
-        const registry = TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.getSchema(errorIdentifier);
-        }
-        catch (e) {
-            if (dataObject.Message) {
-                dataObject.message = dataObject.Message;
-            }
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
-                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
-            }
-            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
-        }
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
         const exception = new errorSchema.ctor(message);

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/query/AwsQueryProtocol.js

@@ -1,12 +1,13 @@
 import { collectBody, RpcProtocol } from "@smithy/core/protocols";
-import { deref, NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { deref, NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
 import { XmlShapeDeserializer } from "../xml/XmlShapeDeserializer";
 import { QueryShapeSerializer } from "./QueryShapeSerializer";
 export class AwsQueryProtocol extends RpcProtocol {
     options;
     serializer;
     deserializer;
+    mixin = new ProtocolLib();
     constructor(options) {
         super({
             defaultNamespace: options.defaultNamespace,
@@ -51,7 +52,7 @@ export class AwsQueryProtocol extends RpcProtocol {
             request.body = request.body.slice(-1);
         }
         try {
-            request.headers["content-length"] = String(calculateBodyLength(request.body));
+            request.headers["content-length"] = this.mixin.calculateContentLength(request.body, this.serdeContext);
         }
         catch (e) { }
         return request;
@@ -88,36 +89,8 @@ export class AwsQueryProtocol extends RpcProtocol {
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        let errorName = errorIdentifier;
-        if (errorIdentifier.includes("#")) {
-            [namespace, errorName] = errorIdentifier.split("#");
-        }
         const errorData = this.loadQueryError(dataObject);
-        const errorMetadata = {
-            $metadata: metadata,
-            $response: response,
-            $fault: response.statusCode <= 500 ? "client" : "server",
-        };
-        const registry = TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName);
-            if (!errorSchema) {
-                errorSchema = registry.getSchema(errorIdentifier);
-            }
-        }
-        catch (e) {
-            if (errorData.Message) {
-                errorData.message = errorData.Message;
-            }
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
-                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
-            }
-            throw Object.assign(new Error(errorName), errorMetadata, errorData);
-        }
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, (registry, errorName) => registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName));
         const ns = NormalizedSchema.of(errorSchema);
         const message = this.loadQueryErrorMessage(dataObject);
         const exception = new errorSchema.ctor(message);

package/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/AwsRestXmlProtocol.js

@@ -1,12 +1,13 @@
 import { HttpBindingProtocol, HttpInterceptingShapeDeserializer, HttpInterceptingShapeSerializer, } from "@smithy/core/protocols";
-import { NormalizedSchema, SCHEMA, TypeRegistry } from "@smithy/core/schema";
-import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { ProtocolLib } from "../ProtocolLib";
 import { loadRestXmlErrorCode } from "./parseXmlBody";
 import { XmlCodec } from "./XmlCodec";
 export class AwsRestXmlProtocol extends HttpBindingProtocol {
     codec;
     serializer;
     deserializer;
+    mixin = new ProtocolLib();
     constructor(options) {
         super(options);
         const settings = {
@@ -30,35 +31,11 @@ export class AwsRestXmlProtocol extends HttpBindingProtocol {
     }
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
-        const ns = NormalizedSchema.of(operationSchema.input);
-        const members = ns.getMemberSchemas();
+        const inputSchema = NormalizedSchema.of(operationSchema.input);
         if (!request.headers["content-type"]) {
-            const httpPayloadMember = Object.values(members).find((m) => {
-                return !!m.getMergedTraits().httpPayload;
-            });
-            if (httpPayloadMember) {
-                const mediaType = httpPayloadMember.getMergedTraits().mediaType;
-                if (mediaType) {
-                    request.headers["content-type"] = mediaType;
-                }
-                else if (httpPayloadMember.isStringSchema()) {
-                    request.headers["content-type"] = "text/plain";
-                }
-                else if (httpPayloadMember.isBlobSchema()) {
-                    request.headers["content-type"] = "application/octet-stream";
-                }
-                else {
-                    request.headers["content-type"] = this.getDefaultContentType();
-                }
-            }
-            else if (!ns.isUnitSchema()) {
-                const hasBody = Object.values(members).find((m) => {
-                    const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
-                    return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && httpPrefixHeaders === void 0;
-                });
-                if (hasBody) {
-                    request.headers["content-type"] = this.getDefaultContentType();
-                }
+            const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
+            if (contentType) {
+                request.headers["content-type"] = contentType;
             }
         }
         if (request.headers["content-type"] === this.getDefaultContentType()) {
@@ -68,7 +45,7 @@ export class AwsRestXmlProtocol extends HttpBindingProtocol {
         }
         if (request.body) {
             try {
-                request.headers["content-length"] = String(calculateBodyLength(request.body));
+                request.headers["content-length"] = this.mixin.calculateContentLength(request.body, this.serdeContext);
             }
             catch (e) { }
         }
@@ -79,32 +56,7 @@ export class AwsRestXmlProtocol extends HttpBindingProtocol {
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown";
-        let namespace = this.options.defaultNamespace;
-        let errorName = errorIdentifier;
-        if (errorIdentifier.includes("#")) {
-            [namespace, errorName] = errorIdentifier.split("#");
-        }
-        const errorMetadata = {
-            $metadata: metadata,
-            $response: response,
-            $fault: response.statusCode <= 500 ? "client" : "server",
-        };
-        const registry = TypeRegistry.for(namespace);
-        let errorSchema;
-        try {
-            errorSchema = registry.getSchema(errorIdentifier);
-        }
-        catch (e) {
-            if (dataObject.Message) {
-                dataObject.message = dataObject.Message;
-            }
-            const baseExceptionSchema = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace).getBaseException();
-            if (baseExceptionSchema) {
-                const ErrorCtor = baseExceptionSchema.ctor;
-                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
-            }
-            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
-        }
+        const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "Unknown";
         const exception = new errorSchema.ctor(message);

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/ProtocolLib.d.ts

@@ -0,0 +1,57 @@
+import { ErrorSchema, NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import type { HttpResponse as IHttpResponse, MetadataBearer, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+/**
+ * @internal
+ */
+type ErrorMetadataBearer = MetadataBearer & {
+    $response: IHttpResponse;
+    $fault: "client" | "server";
+};
+/**
+ * Shared code for Protocols.
+ *
+ * @internal
+ */
+export declare class ProtocolLib {
+    /**
+     * @param body - to be inspected.
+     * @param serdeContext - this is a subset type but in practice is the client.config having a property called bodyLengthChecker.
+     *
+     * @returns content-length value for the body if possible.
+     * @throws Error and should be caught and handled if not possible to determine length.
+     */
+    calculateContentLength(body: any, serdeContext?: SerdeFunctions): string;
+    /**
+     * This is only for REST protocols.
+     *
+     * @param defaultContentType - of the protocol.
+     * @param inputSchema - schema for which to determine content type.
+     *
+     * @returns content-type header value or undefined when not applicable.
+     */
+    resolveRestContentType(defaultContentType: string, inputSchema: NormalizedSchema): string | undefined;
+    /**
+     * Shared code for finding error schema or throwing an unmodeled base error.
+     * @returns error schema and error metadata.
+     *
+     * @throws ServiceBaseException or generic Error if no error schema could be found.
+     */
+    getErrorSchemaOrThrowBaseException(errorIdentifier: string, defaultNamespace: string, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata, getErrorSchema?: (registry: TypeRegistry, errorName: string) => ErrorSchema): Promise<{
+        errorSchema: ErrorSchema;
+        errorMetadata: ErrorMetadataBearer;
+    }>;
+    /**
+     * Reads the x-amzn-query-error header for awsQuery compatibility.
+     *
+     * @param output - values that will be assigned to an error object.
+     * @param response - from which to read awsQueryError headers.
+     */
+    setQueryCompatError(output: Record<string, any>, response: IHttpResponse): void;
+    /**
+     * Assigns Error, Type, Code from the awsQuery error object to the output error object.
+     * @param queryCompatErrorData - query compat error object.
+     * @param errorData - canonical error object returned to the caller.
+     */
+    queryCompatOutput(queryCompatErrorData: any, errorData: any): void;
+}
+export {};

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/cbor/AwsSmithyRpcV2CborProtocol.d.ts

@@ -0,0 +1,23 @@
+import { SmithyRpcV2CborProtocol } from "@smithy/core/cbor";
+import type { EndpointBearer, HandlerExecutionContext, HttpRequest, HttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+/**
+ * Extends the Smithy implementation to add AwsQueryCompatibility support.
+ *
+ * @alpha
+ */
+export declare class AwsSmithyRpcV2CborProtocol extends SmithyRpcV2CborProtocol {
+    private readonly awsQueryCompatible;
+    private readonly mixin;
+    constructor({ defaultNamespace, awsQueryCompatible, }: {
+        defaultNamespace: string;
+        awsQueryCompatible?: boolean;
+    });
+    /**
+     * @override
+     */
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<HttpRequest>;
+    /**
+     * @override
+     */
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+}

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./cbor/AwsSmithyRpcV2CborProtocol";
 export * from "./coercing-serializers";
 export * from "./json/AwsJson1_0Protocol";
 export * from "./json/AwsJson1_1Protocol";

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/AwsJson1_0Protocol.d.ts

@@ -4,9 +4,10 @@ import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
  * @see https://smithy.io/2.0/aws/protocols/aws-json-1_1-protocol.html#differences-between-awsjson1-0-and-awsjson1-1
  */
 export declare class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
-    constructor({ defaultNamespace, serviceTarget }: {
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }: {
         defaultNamespace: string;
         serviceTarget: string;
+        awsQueryCompatible?: boolean;
     });
     getShapeId(): string;
     protected getJsonRpcVersion(): "1.0";

package/node_modules/@aws-sdk/core/dist-types/submodules/protocols/json/AwsJson1_1Protocol.d.ts

@@ -4,9 +4,10 @@ import { AwsJsonRpcProtocol } from "./AwsJsonRpcProtocol";
  * @see https://smithy.io/2.0/aws/protocols/aws-json-1_1-protocol.html#differences-between-awsjson1-0-and-awsjson1-1
  */
 export declare class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
-    constructor({ defaultNamespace, serviceTarget }: {
+    constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }: {
         defaultNamespace: string;
         serviceTarget: string;
+        awsQueryCompatible?: boolean;
     });
     getShapeId(): string;
     protected getJsonRpcVersion(): "1.1";