@mavogel/awscdk-rootmail 0.0.320 → 0.0.322

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

@@ -17,8 +17,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/submodules/serde/index.ts
-var serde_exports = {};
-__export(serde_exports, {
+var index_exports = {};
+__export(index_exports, {
   LazyJsonString: () => LazyJsonString,
   NumericValue: () => NumericValue,
   copyDocumentWithTransform: () => copyDocumentWithTransform,
@@ -59,7 +59,7 @@ __export(serde_exports, {
   strictParseLong: () => strictParseLong,
   strictParseShort: () => strictParseShort
 });
-module.exports = __toCommonJS(serde_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/submodules/serde/copyDocumentWithTransform.ts
 var copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => source;
@@ -518,7 +518,7 @@ var stripLeadingZeroes = (value) => {
 };
 
 // src/submodules/serde/generateIdempotencyToken.ts
-var import_uuid = require("uuid");
+var import_uuid = require("@smithy/uuid");
 
 // src/submodules/serde/lazy-json.ts
 var LazyJsonString = function LazyJsonString2(val) {
@@ -653,11 +653,11 @@ var NumericValue = class _NumericValue {
       return false;
     }
     const _nv = object;
-    const prototypeMatch = _NumericValue.prototype.isPrototypeOf(object.constructor?.prototype);
+    const prototypeMatch = _NumericValue.prototype.isPrototypeOf(object);
     if (prototypeMatch) {
       return prototypeMatch;
     }
-    if (typeof _nv.string === "string" && typeof _nv.type === "string" && _nv.constructor?.name === "NumericValue") {
+    if (typeof _nv.string === "string" && typeof _nv.type === "string" && _nv.constructor?.name?.endsWith("NumericValue")) {
       return true;
     }
     return prototypeMatch;

package/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js

@@ -1,4 +1,3 @@
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 import { resolveAuthOptions } from "./resolveAuthOptions";
 function convertHttpAuthSchemesToMap(httpAuthSchemes) {

package/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js

@@ -1,5 +1,4 @@
 import { HttpRequest } from "@smithy/protocol-http";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 const defaultErrorHandler = (signingProperties) => (error) => {
     throw error;

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

@@ -1,5 +1,5 @@
 import { RpcProtocol } from "@smithy/core/protocols";
-import { deref, TypeRegistry } from "@smithy/core/schema";
+import { deref, NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
 import { getSmithyContext } from "@smithy/util-middleware";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
@@ -19,9 +19,9 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
     async serializeRequest(operationSchema, input, context) {
         const request = await super.serializeRequest(operationSchema, input, context);
         Object.assign(request.headers, {
-            "content-type": "application/cbor",
+            "content-type": this.getDefaultContentType(),
             "smithy-protocol": "rpc-v2-cbor",
-            accept: "application/cbor",
+            accept: this.getDefaultContentType(),
         });
         if (deref(operationSchema.input) === "unit") {
             delete request.body;
@@ -51,24 +51,47 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
         return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
-        const error = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
+        const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
         let namespace = this.options.defaultNamespace;
-        if (error.includes("#")) {
-            [namespace] = error.split("#");
+        if (errorName.includes("#")) {
+            [namespace] = errorName.split("#");
         }
+        const errorMetadata = {
+            $metadata: metadata,
+            $response: response,
+            $fault: response.statusCode <= 500 ? "client" : "server",
+        };
         const registry = TypeRegistry.for(namespace);
-        const errorSchema = registry.getSchema(error);
-        if (!errorSchema) {
-            throw new Error("schema not found for " + error);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorName);
+        }
+        catch (e) {
+            if (dataObject.Message) {
+                dataObject.message = dataObject.Message;
+            }
+            const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            const baseExceptionSchema = synthetic.getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
+                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+            }
+            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
         }
+        const ns = NormalizedSchema.of(errorSchema);
+        const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new errorSchema.ctor(message);
-        Object.assign(exception, {
-            $metadata: metadata,
-            $response: response,
+        const exception = new ErrorCtor(message);
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            output[name] = this.deserializer.readValue(member, dataObject[name]);
+        }
+        throw Object.assign(exception, errorMetadata, {
+            $fault: ns.getMergedTraits().error,
             message,
-            ...dataObject,
-        });
-        throw exception;
+        }, output);
+    }
+    getDefaultContentType() {
+        return "application/cbor";
     }
 }

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

@@ -1,3 +1,37 @@
 export function printBytes(bytes) {
-    return [...bytes].map((n) => ("0".repeat(8) + n.toString(2)).slice(-8) + ` (${n})`);
+    return [...bytes].map((n) => {
+        const pad = (num) => ("0".repeat(8) + num.toString(2)).slice(-8);
+        const b = pad(n);
+        const [maj, min] = [b.slice(0, 3), b.slice(3)];
+        let dmaj = "";
+        switch (maj) {
+            case "000":
+                dmaj = "0 - Uint64";
+                break;
+            case "001":
+                dmaj = "1 - Neg Uint64";
+                break;
+            case "010":
+                dmaj = "2 - unstructured bytestring";
+                break;
+            case "011":
+                dmaj = "3 - utf8 string";
+                break;
+            case "100":
+                dmaj = "4 - list";
+                break;
+            case "101":
+                dmaj = "5 - map";
+                break;
+            case "110":
+                dmaj = "6 - tag";
+                break;
+            case "111":
+                dmaj = "7 - special";
+                break;
+            default:
+                dmaj = String(parseInt(maj, 2));
+        }
+        return `${maj}_${min} (${dmaj}, ${parseInt(min, 2)})`;
+    });
 }

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

@@ -2,7 +2,7 @@ import { collectBody } from "@smithy/core/protocols";
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { calculateBodyLength } from "@smithy/util-body-length-browser";
 import { cbor } from "./cbor";
-import { tag, tagSymbol } from "./cbor-types";
+import { tag } from "./cbor-types";
 export const parseCborBody = (streamBody, context) => {
     return collectBody(streamBody, context).then(async (bytes) => {
         if (bytes.length) {

package/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -0,0 +1,200 @@
+import { SCHEMA } from "@smithy/core/schema";
+import { fromUtf8 } from "@smithy/util-utf8";
+export class EventStreamSerde {
+    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) {
+        this.marshaller = marshaller;
+        this.serializer = serializer;
+        this.deserializer = deserializer;
+        this.serdeContext = serdeContext;
+        this.defaultContentType = defaultContentType;
+    }
+    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
+        const marshaller = this.marshaller;
+        const eventStreamMember = requestSchema.getEventStreamMember();
+        const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
+        const memberSchemas = unionSchema.getMemberSchemas();
+        const serializer = this.serializer;
+        const defaultContentType = this.defaultContentType;
+        const initialRequestMarker = Symbol("initialRequestMarker");
+        const eventStreamIterable = {
+            async *[Symbol.asyncIterator]() {
+                if (initialRequest) {
+                    const headers = {
+                        ":event-type": { type: "string", value: "initial-request" },
+                        ":message-type": { type: "string", value: "event" },
+                        ":content-type": { type: "string", value: defaultContentType },
+                    };
+                    serializer.write(requestSchema, initialRequest);
+                    const body = serializer.flush();
+                    yield {
+                        [initialRequestMarker]: true,
+                        headers,
+                        body,
+                    };
+                }
+                for await (const page of eventStream) {
+                    yield page;
+                }
+            },
+        };
+        return marshaller.serialize(eventStreamIterable, (event) => {
+            if (event[initialRequestMarker]) {
+                return {
+                    headers: event.headers,
+                    body: event.body,
+                };
+            }
+            const unionMember = Object.keys(event).find((key) => {
+                return key !== "__type";
+            }) ?? "";
+            const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
+            const headers = {
+                ":event-type": { type: "string", value: eventType },
+                ":message-type": { type: "string", value: "event" },
+                ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
+                ...additionalHeaders,
+            };
+            return {
+                headers,
+                body,
+            };
+        });
+    }
+    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
+        const marshaller = this.marshaller;
+        const eventStreamMember = responseSchema.getEventStreamMember();
+        const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
+        const memberSchemas = unionSchema.getMemberSchemas();
+        const initialResponseMarker = Symbol("initialResponseMarker");
+        const asyncIterable = marshaller.deserialize(response.body, async (event) => {
+            const unionMember = Object.keys(event).find((key) => {
+                return key !== "__type";
+            }) ?? "";
+            if (unionMember === "initial-response") {
+                const dataObject = await this.deserializer.read(responseSchema, event[unionMember].body);
+                delete dataObject[eventStreamMember];
+                return {
+                    [initialResponseMarker]: true,
+                    ...dataObject,
+                };
+            }
+            else if (unionMember in memberSchemas) {
+                const eventStreamSchema = memberSchemas[unionMember];
+                return {
+                    [unionMember]: await this.deserializer.read(eventStreamSchema, event[unionMember].body),
+                };
+            }
+            else {
+                return {
+                    $unknown: event,
+                };
+            }
+        });
+        const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+        const firstEvent = await asyncIterator.next();
+        if (firstEvent.done) {
+            return asyncIterable;
+        }
+        if (firstEvent.value?.[initialResponseMarker]) {
+            if (!responseSchema) {
+                throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
+            }
+            for (const [key, value] of Object.entries(firstEvent.value)) {
+                initialResponseContainer[key] = value;
+            }
+        }
+        return {
+            async *[Symbol.asyncIterator]() {
+                if (!firstEvent?.value?.[initialResponseMarker]) {
+                    yield firstEvent.value;
+                }
+                while (true) {
+                    const { done, value } = await asyncIterator.next();
+                    if (done) {
+                        break;
+                    }
+                    yield value;
+                }
+            },
+        };
+    }
+    writeEventBody(unionMember, unionSchema, event) {
+        const serializer = this.serializer;
+        let eventType = unionMember;
+        let explicitPayloadMember = null;
+        let explicitPayloadContentType;
+        const isKnownSchema = unionSchema.hasMemberSchema(unionMember);
+        const additionalHeaders = {};
+        if (!isKnownSchema) {
+            const [type, value] = event[unionMember];
+            eventType = type;
+            serializer.write(SCHEMA.DOCUMENT, value);
+        }
+        else {
+            const eventSchema = unionSchema.getMemberSchema(unionMember);
+            if (eventSchema.isStructSchema()) {
+                for (const [memberName, memberSchema] of eventSchema.structIterator()) {
+                    const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
+                    if (eventPayload) {
+                        explicitPayloadMember = memberName;
+                        break;
+                    }
+                    else if (eventHeader) {
+                        const value = event[unionMember][memberName];
+                        let type = "binary";
+                        if (memberSchema.isNumericSchema()) {
+                            if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
+                                type = "integer";
+                            }
+                            else {
+                                type = "long";
+                            }
+                        }
+                        else if (memberSchema.isTimestampSchema()) {
+                            type = "timestamp";
+                        }
+                        else if (memberSchema.isStringSchema()) {
+                            type = "string";
+                        }
+                        else if (memberSchema.isBooleanSchema()) {
+                            type = "boolean";
+                        }
+                        if (value != null) {
+                            additionalHeaders[memberName] = {
+                                type,
+                                value,
+                            };
+                            delete event[unionMember][memberName];
+                        }
+                    }
+                }
+                if (explicitPayloadMember !== null) {
+                    const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
+                    if (payloadSchema.isBlobSchema()) {
+                        explicitPayloadContentType = "application/octet-stream";
+                    }
+                    else if (payloadSchema.isStringSchema()) {
+                        explicitPayloadContentType = "text/plain";
+                    }
+                    serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
+                }
+                else {
+                    serializer.write(eventSchema, event[unionMember]);
+                }
+            }
+            else {
+                throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
+            }
+        }
+        const messageSerialization = serializer.flush();
+        const body = typeof messageSerialization === "string"
+            ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization)
+            : messageSerialization;
+        return {
+            body,
+            eventType,
+            explicitPayloadContentType,
+            additionalHeaders,
+        };
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./EventStreamSerde";

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

@@ -56,7 +56,12 @@ export class HttpBindingProtocol extends HttpProtocol {
                 if (isStreaming) {
                     const isEventStream = memberNs.isStructSchema();
                     if (isEventStream) {
-                        throw new Error("serialization of event streams is not yet implemented");
+                        if (input[memberName]) {
+                            payload = await this.serializeEventStream({
+                                eventStream: input[memberName],
+                                requestSchema: ns,
+                            });
+                        }
                     }
                     else {
                         payload = inputMemberValue;
@@ -115,14 +120,13 @@ export class HttpBindingProtocol extends HttpProtocol {
         if (traits.httpQueryParams) {
             for (const [key, val] of Object.entries(data)) {
                 if (!(key in query)) {
-                    this.serializeQuery(NormalizedSchema.of([
-                        ns.getValueSchema(),
-                        {
-                            ...traits,
-                            httpQuery: key,
-                            httpQueryParams: undefined,
-                        },
-                    ]), val, query);
+                    const valueSchema = ns.getValueSchema();
+                    Object.assign(valueSchema.getMergedTraits(), {
+                        ...traits,
+                        httpQuery: key,
+                        httpQueryParams: undefined,
+                    });
+                    this.serializeQuery(valueSchema, val, query);
                 }
             }
             return;
@@ -171,11 +175,8 @@ export class HttpBindingProtocol extends HttpProtocol {
                 }
             }
         }
-        const output = {
-            $metadata: this.deserializeMetadata(response),
-            ...dataObject,
-        };
-        return output;
+        dataObject.$metadata = this.deserializeMetadata(response);
+        return dataObject;
     }
     async deserializeHttpMessage(schema, context, response, arg4, arg5) {
         let dataObject;
@@ -195,26 +196,9 @@ export class HttpBindingProtocol extends HttpProtocol {
                 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,
-                                };
-                            }
+                        dataObject[memberName] = await this.deserializeEventStream({
+                            response,
+                            responseSchema: ns,
                         });
                     }
                     else {
@@ -234,6 +218,7 @@ export class HttpBindingProtocol extends HttpProtocol {
                 if (null != value) {
                     if (memberSchema.isListSchema()) {
                         const headerListValueSchema = memberSchema.getValueSchema();
+                        headerListValueSchema.getMergedTraits().httpHeader = key;
                         let sections;
                         if (headerListValueSchema.isTimestampSchema() &&
                             headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
@@ -244,7 +229,7 @@ export class HttpBindingProtocol extends HttpProtocol {
                         }
                         const list = [];
                         for (const section of sections) {
-                            list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], section.trim()));
+                            list.push(await deserializer.read(headerListValueSchema, section.trim()));
                         }
                         dataObject[memberName] = list;
                     }
@@ -257,7 +242,9 @@ export class HttpBindingProtocol extends HttpProtocol {
                 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);
+                        const valueSchema = memberSchema.getValueSchema();
+                        valueSchema.getMergedTraits().httpHeader = header;
+                        dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
                     }
                 }
             }

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

@@ -72,6 +72,35 @@ export class HttpProtocol {
             cfId: output.headers["x-amz-cf-id"],
         };
     }
+    async serializeEventStream({ eventStream, requestSchema, initialRequest, }) {
+        const eventStreamSerde = await this.loadEventStreamCapability();
+        return eventStreamSerde.serializeEventStream({
+            eventStream,
+            requestSchema,
+            initialRequest,
+        });
+    }
+    async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) {
+        const eventStreamSerde = await this.loadEventStreamCapability();
+        return eventStreamSerde.deserializeEventStream({
+            response,
+            responseSchema,
+            initialResponseContainer,
+        });
+    }
+    async loadEventStreamCapability() {
+        const { EventStreamSerde } = await import("@smithy/core/event-streams");
+        return new EventStreamSerde({
+            marshaller: this.getEventStreamMarshaller(),
+            serializer: this.serializer,
+            deserializer: this.deserializer,
+            serdeContext: this.serdeContext,
+            defaultContentType: this.getDefaultContentType(),
+        });
+    }
+    getDefaultContentType() {
+        throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
+    }
     async deserializeHttpMessage(schema, context, response, arg4, arg5) {
         void schema;
         void context;
@@ -80,4 +109,11 @@ export class HttpProtocol {
         void arg5;
         return [];
     }
+    getEventStreamMarshaller() {
+        const context = this.serdeContext;
+        if (!context.eventStreamMarshaller) {
+            throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
+        }
+        return context.eventStreamMarshaller;
+    }
 }

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

@@ -29,8 +29,27 @@ export class RpcProtocol extends HttpProtocol {
             ...input,
         };
         if (input) {
-            serializer.write(schema, _input);
-            payload = serializer.flush();
+            const eventStreamMember = ns.getEventStreamMember();
+            if (eventStreamMember) {
+                if (_input[eventStreamMember]) {
+                    const initialRequest = {};
+                    for (const [memberName, memberSchema] of ns.structIterator()) {
+                        if (memberName !== eventStreamMember && _input[memberName]) {
+                            serializer.write(memberSchema, _input[memberName]);
+                            initialRequest[memberName] = serializer.flush();
+                        }
+                    }
+                    payload = await this.serializeEventStream({
+                        eventStream: _input[eventStreamMember],
+                        requestSchema: ns,
+                        initialRequest,
+                    });
+                }
+            }
+            else {
+                serializer.write(schema, _input);
+                payload = serializer.flush();
+            }
         }
         request.headers = headers;
         request.query = query;
@@ -55,14 +74,21 @@ export class RpcProtocol extends HttpProtocol {
             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 eventStreamMember = ns.getEventStreamMember();
+        if (eventStreamMember) {
+            dataObject[eventStreamMember] = await this.deserializeEventStream({
+                response,
+                responseSchema: ns,
+                initialResponseContainer: dataObject,
+            });
         }
-        const output = {
-            $metadata: this.deserializeMetadata(response),
-            ...dataObject,
-        };
-        return output;
+        else {
+            const bytes = await collectBody(response.body, context);
+            if (bytes.byteLength > 0) {
+                Object.assign(dataObject, await deserializer.read(ns, bytes));
+            }
+        }
+        dataObject.$metadata = this.deserializeMetadata(response);
+        return dataObject;
     }
 }

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

@@ -1,6 +1,7 @@
 export * from "./collect-stream-body";
 export * from "./extended-encode-uri-component";
 export * from "./HttpBindingProtocol";
+export * from "./HttpProtocol";
 export * from "./RpcProtocol";
 export * from "./requestBuilder";
 export * from "./resolve-path";

package/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js

@@ -1,7 +1,8 @@
 export class TypeRegistry {
-    constructor(namespace, schemas = new Map()) {
+    constructor(namespace, schemas = new Map(), exceptions = new Map()) {
         this.namespace = namespace;
         this.schemas = schemas;
+        this.exceptions = exceptions;
     }
     static for(namespace) {
         if (!TypeRegistry.registries.has(namespace)) {
@@ -11,8 +12,7 @@ export class TypeRegistry {
     }
     register(shapeId, schema) {
         const qualifiedName = this.normalizeShapeId(shapeId);
-        const registry = TypeRegistry.for(this.getNamespace(shapeId));
-        registry.schemas.set(qualifiedName, schema);
+        this.schemas.set(qualifiedName, schema);
     }
     getSchema(shapeId) {
         const id = this.normalizeShapeId(shapeId);
@@ -21,6 +21,12 @@ export class TypeRegistry {
         }
         return this.schemas.get(id);
     }
+    registerError(errorSchema, ctor) {
+        this.exceptions.set(errorSchema, ctor);
+    }
+    getErrorCtor(errorSchema) {
+        return this.exceptions.get(errorSchema);
+    }
     getBaseException() {
         for (const [id, schema] of this.schemas.entries()) {
             if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
@@ -32,9 +38,9 @@ export class TypeRegistry {
     find(predicate) {
         return [...this.schemas.values()].find(predicate);
     }
-    destroy() {
-        TypeRegistry.registries.delete(this.namespace);
+    clear() {
         this.schemas.clear();
+        this.exceptions.clear();
     }
     normalizeShapeId(shapeId) {
         if (shapeId.includes("#")) {