@mavogel/awscdk-rootmail 0.1.28 → 0.1.30

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -1,7 +1,7 @@
 const { nv, NumericValue, calculateBodyLength, generateIdempotencyToken, fromBase64, _parseEpochTimestamp } = require("@smithy/core/serde");
-const { hasOwn, getSmithyContext } = require("@smithy/core/transport");
-const { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require("@smithy/core/protocols");
-const { NormalizedSchema, deref, TypeRegistry } = require("@smithy/core/schema");
+const { hasOwn } = require("@smithy/core/transport");
+const { HttpRequest, collectBody, SerdeContext, AbstractRpcV2Protocol } = require("@smithy/core/protocols");
+const { NormalizedSchema, TypeRegistry } = require("@smithy/core/schema");
 
 const majorUint64 = 0;
 const majorNegativeInt64 = 1;
@@ -2216,51 +2216,27 @@ class CborCodec extends SerdeContext {
     }
 }
 
-class SmithyRpcV2CborProtocol extends RpcProtocol {
+class SmithyRpcV2CborProtocol extends AbstractRpcV2Protocol {
     codec = new CborCodec();
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace, errorTypeRegistries, }) {
-        super({ defaultNamespace, errorTypeRegistries });
-    }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
     }
     getPayloadCodec() {
         return this.codec;
     }
-    async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
-        Object.assign(request.headers, {
-            "content-type": this.getDefaultContentType(),
-            "smithy-protocol": "rpc-v2-cbor",
-            accept: this.getDefaultContentType(),
-        });
-        if (deref(operationSchema.input) === "unit") {
-            delete request.body;
-            delete request.headers["content-type"];
-        }
-        else {
-            if (!request.body) {
-                this.serializer.write(15, {});
-                request.body = this.serializer.flush();
-            }
-            if (request.body instanceof Uint8Array) {
-                request.headers["content-length"] = String(request.body.byteLength);
-            }
-        }
-        const { service, operation } = getSmithyContext(context);
-        const path = `/service/${service}/operation/${operation}`;
-        if (request.path.endsWith("/")) {
-            request.path += path.slice(1);
+    getSmithyProtocolHeaderValue() {
+        return "rpc-v2-cbor";
+    }
+    applyEmptyBody(request) {
+        if (!request.body) {
+            this.serializer.write(15, {});
+            request.body = this.serializer.flush();
         }
-        else {
-            request.path += path;
+        if (request.body instanceof Uint8Array) {
+            request.headers["content-length"] = String(request.body.byteLength);
         }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";

package/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js

@@ -574,7 +574,7 @@ class RpcProtocol extends HttpProtocol {
         const deserializer = this.deserializer;
         const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
-        if (response.statusCode >= 300) {
+        if (this.isErrorResponse(response.statusCode)) {
             const bytes = await collectBody(response.body, context);
             if (bytes.byteLength > 0) {
                 Object.assign(dataObject, await deserializer.read(15, bytes));
@@ -606,6 +606,42 @@ class RpcProtocol extends HttpProtocol {
         dataObject.$metadata = this.deserializeMetadata(response);
         return dataObject;
     }
+    isErrorResponse(statusCode) {
+        return statusCode >= 300;
+    }
+}
+
+class AbstractRpcV2Protocol extends RpcProtocol {
+    constructor({ defaultNamespace, errorTypeRegistries, }) {
+        super({ defaultNamespace, errorTypeRegistries });
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        Object.assign(request.headers, {
+            "content-type": this.getDefaultContentType(),
+            "smithy-protocol": this.getSmithyProtocolHeaderValue(),
+            accept: this.getDefaultContentType(),
+        });
+        if (deref(operationSchema.input) === "unit") {
+            delete request.body;
+            delete request.headers["content-type"];
+        }
+        else {
+            this.applyEmptyBody(request);
+        }
+        const { service, operation } = getSmithyContext(context);
+        const path = `/service/${service}/operation/${operation}`;
+        if (request.path.endsWith("/")) {
+            request.path += path.slice(1);
+        }
+        else {
+            request.path += path;
+        }
+        return request;
+    }
+    isErrorResponse(statusCode) {
+        return statusCode !== 200;
+    }
 }
 
 const resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
@@ -2240,7 +2276,7 @@ class JsonCodec2 extends SerdeContextConfig {
     }
 }
 
-class SmithyRpcV2JsonProtocol extends RpcProtocol {
+class SmithyRpcV2JsonProtocol extends AbstractRpcV2Protocol {
     codec = new JsonCodec2({
         timestampFormat: {
             useTrait: false,
@@ -2251,41 +2287,19 @@ class SmithyRpcV2JsonProtocol extends RpcProtocol {
     });
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace, errorTypeRegistries, }) {
-        super({ defaultNamespace, errorTypeRegistries });
-    }
     getShapeId() {
         return "smithy.protocols#rpcv2Json";
     }
     getPayloadCodec() {
         return this.codec;
     }
-    async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
-        Object.assign(request.headers, {
-            "content-type": this.getDefaultContentType(),
-            "smithy-protocol": "rpc-v2-json",
-            accept: this.getDefaultContentType(),
-        });
-        if (deref(operationSchema.input) === "unit") {
-            delete request.body;
-            delete request.headers["content-type"];
-        }
-        else if (!request.body) {
+    getSmithyProtocolHeaderValue() {
+        return "rpc-v2-json";
+    }
+    applyEmptyBody(request) {
+        if (!request.body) {
             request.body = "{}";
         }
-        const { service, operation } = getSmithyContext(context);
-        const path = `/service/${service}/operation/${operation}`;
-        if (request.path.endsWith("/")) {
-            request.path += path.slice(1);
-        }
-        else {
-            request.path += path;
-        }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorName = loadSmithyRpcV2JsonErrorCode(response, dataObject) ?? "Unknown";
@@ -2753,6 +2767,7 @@ class JsonCodec extends SerdeContextConfig {
     }
 }
 
+exports.AbstractRpcV2Protocol = AbstractRpcV2Protocol;
 exports.Field = Field;
 exports.Fields = Fields;
 exports.FromStringShapeDeserializer = FromStringShapeDeserializer;

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -1,53 +1,28 @@
-import { RpcProtocol } from "@smithy/core/protocols";
-import { NormalizedSchema, TypeRegistry, deref } from "@smithy/core/schema";
-import { getSmithyContext } from "@smithy/core/transport";
+import { AbstractRpcV2Protocol } from "@smithy/core/protocols";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
-export class SmithyRpcV2CborProtocol extends RpcProtocol {
+export class SmithyRpcV2CborProtocol extends AbstractRpcV2Protocol {
     codec = new CborCodec();
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace, errorTypeRegistries, }) {
-        super({ defaultNamespace, errorTypeRegistries });
-    }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
     }
     getPayloadCodec() {
         return this.codec;
     }
-    async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
-        Object.assign(request.headers, {
-            "content-type": this.getDefaultContentType(),
-            "smithy-protocol": "rpc-v2-cbor",
-            accept: this.getDefaultContentType(),
-        });
-        if (deref(operationSchema.input) === "unit") {
-            delete request.body;
-            delete request.headers["content-type"];
-        }
-        else {
-            if (!request.body) {
-                this.serializer.write(15, {});
-                request.body = this.serializer.flush();
-            }
-            if (request.body instanceof Uint8Array) {
-                request.headers["content-length"] = String(request.body.byteLength);
-            }
-        }
-        const { service, operation } = getSmithyContext(context);
-        const path = `/service/${service}/operation/${operation}`;
-        if (request.path.endsWith("/")) {
-            request.path += path.slice(1);
+    getSmithyProtocolHeaderValue() {
+        return "rpc-v2-cbor";
+    }
+    applyEmptyBody(request) {
+        if (!request.body) {
+            this.serializer.write(15, {});
+            request.body = this.serializer.flush();
         }
-        else {
-            request.path += path;
+        if (request.body instanceof Uint8Array) {
+            request.headers["content-length"] = String(request.body.byteLength);
         }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";

package/node_modules/@smithy/core/dist-es/submodules/protocols/AbstractRpcV2Protocol.js

@@ -0,0 +1,35 @@
+import { deref } from "@smithy/core/schema";
+import { getSmithyContext } from "@smithy/core/transport";
+import { RpcProtocol } from "./RpcProtocol";
+export class AbstractRpcV2Protocol extends RpcProtocol {
+    constructor({ defaultNamespace, errorTypeRegistries, }) {
+        super({ defaultNamespace, errorTypeRegistries });
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        Object.assign(request.headers, {
+            "content-type": this.getDefaultContentType(),
+            "smithy-protocol": this.getSmithyProtocolHeaderValue(),
+            accept: this.getDefaultContentType(),
+        });
+        if (deref(operationSchema.input) === "unit") {
+            delete request.body;
+            delete request.headers["content-type"];
+        }
+        else {
+            this.applyEmptyBody(request);
+        }
+        const { service, operation } = getSmithyContext(context);
+        const path = `/service/${service}/operation/${operation}`;
+        if (request.path.endsWith("/")) {
+            request.path += path.slice(1);
+        }
+        else {
+            request.path += path;
+        }
+        return request;
+    }
+    isErrorResponse(statusCode) {
+        return statusCode !== 200;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -59,7 +59,7 @@ export class RpcProtocol extends HttpProtocol {
         const deserializer = this.deserializer;
         const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
-        if (response.statusCode >= 300) {
+        if (this.isErrorResponse(response.statusCode)) {
             const bytes = await collectBody(response.body, context);
             if (bytes.byteLength > 0) {
                 Object.assign(dataObject, await deserializer.read(15, bytes));
@@ -91,4 +91,7 @@ export class RpcProtocol extends HttpProtocol {
         dataObject.$metadata = this.deserializeMetadata(response);
         return dataObject;
     }
+    isErrorResponse(statusCode) {
+        return statusCode >= 300;
+    }
 }

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

@@ -3,6 +3,7 @@ export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
 export { HttpBindingProtocol } from "./HttpBindingProtocol";
 export { HttpProtocol } from "./HttpProtocol";
 export { RpcProtocol } from "./RpcProtocol";
+export { AbstractRpcV2Protocol } from "./AbstractRpcV2Protocol";
 export { RequestBuilder, requestBuilder } from "./requestBuilder";
 export { resolvedPath } from "./resolve-path";
 export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";

package/node_modules/@smithy/core/dist-es/submodules/protocols/json/SmithyRpcV2JsonProtocol.js

@@ -1,9 +1,8 @@
-import { RpcProtocol } from "../RpcProtocol";
-import { NormalizedSchema, TypeRegistry, deref } from "@smithy/core/schema";
-import { getSmithyContext } from "@smithy/core/transport";
+import { AbstractRpcV2Protocol } from "../AbstractRpcV2Protocol";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
 import { JsonCodec2 } from "./codec-v2/JsonCodec2";
 import { loadSmithyRpcV2JsonErrorCode } from "./parseJsonBody";
-export class SmithyRpcV2JsonProtocol extends RpcProtocol {
+export class SmithyRpcV2JsonProtocol extends AbstractRpcV2Protocol {
     codec = new JsonCodec2({
         timestampFormat: {
             useTrait: false,
@@ -14,41 +13,19 @@ export class SmithyRpcV2JsonProtocol extends RpcProtocol {
     });
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace, errorTypeRegistries, }) {
-        super({ defaultNamespace, errorTypeRegistries });
-    }
     getShapeId() {
         return "smithy.protocols#rpcv2Json";
     }
     getPayloadCodec() {
         return this.codec;
     }
-    async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
-        Object.assign(request.headers, {
-            "content-type": this.getDefaultContentType(),
-            "smithy-protocol": "rpc-v2-json",
-            accept: this.getDefaultContentType(),
-        });
-        if (deref(operationSchema.input) === "unit") {
-            delete request.body;
-            delete request.headers["content-type"];
-        }
-        else if (!request.body) {
+    getSmithyProtocolHeaderValue() {
+        return "rpc-v2-json";
+    }
+    applyEmptyBody(request) {
+        if (!request.body) {
             request.body = "{}";
         }
-        const { service, operation } = getSmithyContext(context);
-        const path = `/service/${service}/operation/${operation}`;
-        if (request.path.endsWith("/")) {
-            request.path += path.slice(1);
-        }
-        else {
-            request.path += path;
-        }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorName = loadSmithyRpcV2JsonErrorCode(response, dataObject) ?? "Unknown";

package/node_modules/@smithy/core/dist-types/submodules/cbor/SmithyRpcV2CborProtocol.d.ts

@@ -1,28 +1,19 @@
-import { RpcProtocol } from "@smithy/core/protocols";
-import { TypeRegistry } from "@smithy/core/schema";
-import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+import { AbstractRpcV2Protocol } from "@smithy/core/protocols";
+import type { HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
 import { CborCodec } from "./CborCodec";
 /**
  * Client protocol for Smithy RPCv2 CBOR.
  *
  * @public
  */
-export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
-    /**
-     * @override
-     */
-    protected compositeErrorRegistry: TypeRegistry;
+export declare class SmithyRpcV2CborProtocol extends AbstractRpcV2Protocol {
     private codec;
     protected serializer: import(".").CborShapeSerializer2;
     protected deserializer: import(".").CborShapeDeserializer2;
-    constructor({ defaultNamespace, errorTypeRegistries, }: {
-        defaultNamespace: string;
-        errorTypeRegistries?: TypeRegistry[];
-    });
     getShapeId(): string;
     getPayloadCodec(): CborCodec;
-    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
-    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected getSmithyProtocolHeaderValue(): string;
+    protected applyEmptyBody(request: IHttpRequest): void;
     protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
     protected getDefaultContentType(): string;
 }

package/node_modules/@smithy/core/dist-types/submodules/protocols/AbstractRpcV2Protocol.d.ts

@@ -0,0 +1,45 @@
+import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, OperationSchema, SerdeFunctions } from "@smithy/types";
+import type { TypeRegistry } from "@smithy/core/schema";
+import { RpcProtocol } from "./RpcProtocol";
+/**
+ * Shared abstract base for the Smithy RPC v2 client protocols (JSON and CBOR).
+ *
+ * Factors out the request-framing flow and response status handling that are
+ * identical across both RPC v2 protocols. Concrete protocols supply their
+ * codec, error handling, content type, shape id, and the two per-protocol
+ * request details via {@link getSmithyProtocolHeaderValue} and
+ * {@link applyEmptyBody}.
+ *
+ * @internal
+ */
+export declare abstract class AbstractRpcV2Protocol extends RpcProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    constructor({ defaultNamespace, errorTypeRegistries, }: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    /**
+     * @override
+     *
+     * Per the Smithy RPC v2 specification, the only successful response status
+     * code is 200; any other status code MUST be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
+    /**
+     * @returns the value of the `smithy-protocol` header for this protocol,
+     * e.g. `rpc-v2-json` or `rpc-v2-cbor`.
+     */
+    protected abstract getSmithyProtocolHeaderValue(): string;
+    /**
+     * Applies this protocol's representation of an empty request body when the
+     * operation has a non-unit input but produced no serialized body. Called
+     * only for non-unit inputs.
+     *
+     * @param request - the request being serialized, mutated in place.
+     */
+    protected abstract applyEmptyBody(request: IHttpRequest): void;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/RpcProtocol.d.ts

@@ -13,4 +13,16 @@ export declare abstract class RpcProtocol extends HttpProtocol {
     protected compositeErrorRegistry: TypeRegistry;
     serializeRequest<Input extends object>(operationSchema: OperationSchema, _input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
     deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    /**
+     * Determines whether a response status code indicates an error response that
+     * should be routed to {@link handleError} rather than deserialized as output.
+     *
+     * The default treats any status code of 300 or greater as an error,
+     * preserving the historical behavior for RPC-over-HTTP protocols. Subclasses
+     * whose specification is stricter SHOULD override this.
+     *
+     * @param statusCode - the HTTP response status code.
+     * @returns true if the response should be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
 }

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

@@ -3,6 +3,7 @@ export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
 export { HttpBindingProtocol } from "./HttpBindingProtocol";
 export { HttpProtocol } from "./HttpProtocol";
 export { RpcProtocol } from "./RpcProtocol";
+export { AbstractRpcV2Protocol } from "./AbstractRpcV2Protocol";
 export { RequestBuilder, requestBuilder } from "./requestBuilder";
 export { resolvedPath } from "./resolve-path";
 export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/SmithyRpcV2JsonProtocol.d.ts

@@ -1,28 +1,19 @@
-import { RpcProtocol } from "../RpcProtocol";
-import { TypeRegistry } from "@smithy/core/schema";
-import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { AbstractRpcV2Protocol } from "../AbstractRpcV2Protocol";
+import type { HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
 import { JsonCodec2 } from "./codec-v2/JsonCodec2";
 /**
  * Client protocol for Smithy RPCv2 JSON.
  *
  * @public
  */
-export declare class SmithyRpcV2JsonProtocol extends RpcProtocol {
-    /**
-     * @override
-     */
-    protected compositeErrorRegistry: TypeRegistry;
+export declare class SmithyRpcV2JsonProtocol extends AbstractRpcV2Protocol {
     private codec;
     protected serializer: ShapeSerializer<string | Uint8Array>;
     protected deserializer: ShapeDeserializer<string | Uint8Array>;
-    constructor({ defaultNamespace, errorTypeRegistries, }: {
-        defaultNamespace: string;
-        errorTypeRegistries?: TypeRegistry[];
-    });
     getShapeId(): string;
     getPayloadCodec(): JsonCodec2;
-    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
-    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected getSmithyProtocolHeaderValue(): string;
+    protected applyEmptyBody(request: IHttpRequest): void;
     protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
     protected getDefaultContentType(): string;
 }

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/cbor/SmithyRpcV2CborProtocol.d.ts

@@ -1,28 +1,19 @@
-import { RpcProtocol } from "@smithy/core/protocols";
-import { TypeRegistry } from "@smithy/core/schema";
-import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+import { AbstractRpcV2Protocol } from "@smithy/core/protocols";
+import { HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
 import { CborCodec } from "./CborCodec";
 /**
  * Client protocol for Smithy RPCv2 CBOR.
  *
  * @public
  */
-export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
-    /**
-     * @override
-     */
-    protected compositeErrorRegistry: TypeRegistry;
+export declare class SmithyRpcV2CborProtocol extends AbstractRpcV2Protocol {
     private codec;
     protected serializer: import(".").CborShapeSerializer2;
     protected deserializer: import(".").CborShapeDeserializer2;
-    constructor({ defaultNamespace, errorTypeRegistries, }: {
-        defaultNamespace: string;
-        errorTypeRegistries?: TypeRegistry[];
-    });
     getShapeId(): string;
     getPayloadCodec(): CborCodec;
-    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
-    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected getSmithyProtocolHeaderValue(): string;
+    protected applyEmptyBody(request: IHttpRequest): void;
     protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
     protected getDefaultContentType(): string;
 }

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/AbstractRpcV2Protocol.d.ts

@@ -0,0 +1,45 @@
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, OperationSchema, SerdeFunctions } from "@smithy/types";
+import { TypeRegistry } from "@smithy/core/schema";
+import { RpcProtocol } from "./RpcProtocol";
+/**
+ * Shared abstract base for the Smithy RPC v2 client protocols (JSON and CBOR).
+ *
+ * Factors out the request-framing flow and response status handling that are
+ * identical across both RPC v2 protocols. Concrete protocols supply their
+ * codec, error handling, content type, shape id, and the two per-protocol
+ * request details via {@link getSmithyProtocolHeaderValue} and
+ * {@link applyEmptyBody}.
+ *
+ * @internal
+ */
+export declare abstract class AbstractRpcV2Protocol extends RpcProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    constructor({ defaultNamespace, errorTypeRegistries, }: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    /**
+     * @override
+     *
+     * Per the Smithy RPC v2 specification, the only successful response status
+     * code is 200; any other status code MUST be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
+    /**
+     * @returns the value of the `smithy-protocol` header for this protocol,
+     * e.g. `rpc-v2-json` or `rpc-v2-cbor`.
+     */
+    protected abstract getSmithyProtocolHeaderValue(): string;
+    /**
+     * Applies this protocol's representation of an empty request body when the
+     * operation has a non-unit input but produced no serialized body. Called
+     * only for non-unit inputs.
+     *
+     * @param request - the request being serialized, mutated in place.
+     */
+    protected abstract applyEmptyBody(request: IHttpRequest): void;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/RpcProtocol.d.ts

@@ -13,4 +13,16 @@ export declare abstract class RpcProtocol extends HttpProtocol {
     protected compositeErrorRegistry: TypeRegistry;
     serializeRequest<Input extends object>(operationSchema: OperationSchema, _input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
     deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    /**
+     * Determines whether a response status code indicates an error response that
+     * should be routed to {@link handleError} rather than deserialized as output.
+     *
+     * The default treats any status code of 300 or greater as an error,
+     * preserving the historical behavior for RPC-over-HTTP protocols. Subclasses
+     * whose specification is stricter SHOULD override this.
+     *
+     * @param statusCode - the HTTP response status code.
+     * @returns true if the response should be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
 }

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/index.d.ts

@@ -3,6 +3,7 @@ export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
 export { HttpBindingProtocol } from "./HttpBindingProtocol";
 export { HttpProtocol } from "./HttpProtocol";
 export { RpcProtocol } from "./RpcProtocol";
+export { AbstractRpcV2Protocol } from "./AbstractRpcV2Protocol";
 export { RequestBuilder, requestBuilder } from "./requestBuilder";
 export { resolvedPath } from "./resolve-path";
 export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";