@mavogel/awscdk-rootmail 0.0.322 → 0.0.324

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

@@ -3,6 +3,6 @@ export * from "./middleware-http-auth-scheme";
 export * from "./middleware-http-signing";
 export * from "./normalizeProvider";
 export { createPaginator } from "./pagination/createPaginator";
-export * from "./protocols/requestBuilder";
+export * from "./request-builder/requestBuilder";
 export * from "./setFeature";
 export * from "./util-identity-and-auth";

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

@@ -1,9 +1,10 @@
+import { SerdeContext } from "@smithy/core/protocols";
 import { NormalizedSchema } from "@smithy/core/schema";
-import { generateIdempotencyToken, parseEpochTimestamp } from "@smithy/core/serde";
+import { _parseEpochTimestamp, generateIdempotencyToken } from "@smithy/core/serde";
 import { fromBase64 } from "@smithy/util-base64";
 import { cbor } from "./cbor";
 import { dateToTag } from "./parseCborBody";
-export class CborCodec {
+export class CborCodec extends SerdeContext {
     createSerializer() {
         const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
@@ -14,14 +15,9 @@ export class CborCodec {
         deserializer.setSerdeContext(this.serdeContext);
         return deserializer;
     }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
 }
-export class CborShapeSerializer {
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
+export class CborShapeSerializer extends SerdeContext {
+    value;
     write(schema, value) {
         this.value = this.serialize(schema, value);
     }
@@ -95,10 +91,7 @@ export class CborShapeSerializer {
         return buffer;
     }
 }
-export class CborShapeDeserializer {
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
+export class CborShapeDeserializer extends SerdeContext {
     read(schema, bytes) {
         const data = cbor.deserialize(bytes);
         return this.readValue(schema, data);
@@ -106,7 +99,7 @@ export class CborShapeDeserializer {
     readValue(_schema, value) {
         const ns = NormalizedSchema.of(_schema);
         if (ns.isTimestampSchema() && typeof value === "number") {
-            return parseEpochTimestamp(value);
+            return _parseEpochTimestamp(value);
         }
         if (ns.isBlobSchema()) {
             if (typeof value === "string") {

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

@@ -4,11 +4,11 @@ import { getSmithyContext } from "@smithy/util-middleware";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
 export class SmithyRpcV2CborProtocol extends RpcProtocol {
+    codec = new CborCodec();
+    serializer = this.codec.createSerializer();
+    deserializer = this.codec.createDeserializer();
     constructor({ defaultNamespace }) {
         super({ defaultNamespace });
-        this.codec = new CborCodec();
-        this.serializer = this.codec.createSerializer();
-        this.deserializer = this.codec.createDeserializer();
     }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";

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

@@ -15,8 +15,8 @@ export function decode(at, to) {
     if (at >= to) {
         throw new Error("unexpected end of (decode) payload.");
     }
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
+    const major = (payload[at] & 0b1110_0000) >> 5;
+    const minor = payload[at] & 0b0001_1111;
     switch (major) {
         case majorUint64:
         case majorNegativeInt64:
@@ -168,13 +168,13 @@ const minorValueToArgumentLength = {
 };
 export function bytesToFloat16(a, b) {
     const sign = a >> 7;
-    const exponent = (a & 124) >> 2;
-    const fraction = ((a & 3) << 8) | b;
+    const exponent = (a & 0b0111_1100) >> 2;
+    const fraction = ((a & 0b0000_0011) << 8) | b;
     const scalar = sign === 0 ? 1 : -1;
     let exponentComponent;
     let summation;
     if (exponent === 0b00000) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return 0;
         }
         else {
@@ -183,7 +183,7 @@ export function bytesToFloat16(a, b) {
         }
     }
     else if (exponent === 0b11111) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return scalar * Infinity;
         }
         else {
@@ -198,7 +198,7 @@ export function bytesToFloat16(a, b) {
     return scalar * (exponentComponent * summation);
 }
 function decodeCount(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload[at] & 0b0001_1111;
     if (minor < 24) {
         _offset = 1;
         return minor;
@@ -241,14 +241,14 @@ function decodeUtf8StringIndefinite(at, to) {
     at += 1;
     const vector = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             const data = alloc(vector.length);
             data.set(vector, 0);
             _offset = at - base + 2;
             return bytesToUtf8(data, 0, data.length);
         }
-        const major = (payload[at] & 224) >> 5;
-        const minor = payload[at] & 31;
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} in indefinite string.`);
         }
@@ -279,14 +279,14 @@ function decodeUnstructuredByteStringIndefinite(at, to) {
     at += 1;
     const vector = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             const data = alloc(vector.length);
             data.set(vector, 0);
             _offset = at - base + 2;
             return data;
         }
-        const major = (payload[at] & 224) >> 5;
-        const minor = payload[at] & 31;
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
         if (major !== majorUnstructuredByteString) {
             throw new Error(`unexpected major type ${major} in indefinite string.`);
         }
@@ -321,7 +321,7 @@ function decodeListIndefinite(at, to) {
     at += 1;
     const list = [];
     for (const base = at; at < to;) {
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             _offset = at - base + 2;
             return list;
         }
@@ -342,7 +342,7 @@ function decodeMap(at, to) {
         if (at >= to) {
             throw new Error("unexpected end of map payload.");
         }
-        const major = (payload[at] & 224) >> 5;
+        const major = (payload[at] & 0b1110_0000) >> 5;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
         }
@@ -363,11 +363,11 @@ function decodeMapIndefinite(at, to) {
         if (at >= to) {
             throw new Error("unexpected end of map payload.");
         }
-        if (payload[at] === 255) {
+        if (payload[at] === 0b1111_1111) {
             _offset = at - base + 2;
             return map;
         }
-        const major = (payload[at] & 224) >> 5;
+        const major = (payload[at] & 0b1110_0000) >> 5;
         if (major !== majorUtf8String) {
             throw new Error(`unexpected major type ${major} for map key.`);
         }
@@ -380,7 +380,7 @@ function decodeMapIndefinite(at, to) {
     throw new Error("expected break marker.");
 }
 function decodeSpecial(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload[at] & 0b0001_1111;
     switch (minor) {
         case specialTrue:
         case specialFalse:

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

@@ -9,11 +9,11 @@ let cursor = 0;
 function ensureSpace(bytes) {
     const remaining = data.byteLength - cursor;
     if (remaining < bytes) {
-        if (cursor < 16000000) {
+        if (cursor < 16_000_000) {
             resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
         }
         else {
-            resize(data.byteLength + bytes + 16000000);
+            resize(data.byteLength + bytes + 16_000_000);
         }
     }
 }
@@ -127,7 +127,7 @@ export function encode(_input) {
             else if (n < 65536) {
                 data[cursor++] = (major << 5) | extendedFloat16;
                 data[cursor++] = n >> 8;
-                data[cursor++] = n & 255;
+                data[cursor++] = n & 0b1111_1111;
             }
             else if (n < 4294967296) {
                 data[cursor++] = (major << 5) | extendedFloat32;
@@ -149,7 +149,7 @@ export function encode(_input) {
                     b >>= BigInt(8);
                 }
                 ensureSpace(bigIntBytes.byteLength * 2);
-                data[cursor++] = nonNegative ? 194 : 195;
+                data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
                 if (USE_BUFFER) {
                     encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
                 }
@@ -191,7 +191,7 @@ export function encode(_input) {
                 const decimalIndex = input.string.indexOf(".");
                 const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
                 const mantissa = BigInt(input.string.replace(".", ""));
-                data[cursor++] = 196;
+                data[cursor++] = 0b110_00100;
                 encodeStack.push(mantissa);
                 encodeStack.push(exponent);
                 encodeHeader(majorList, 2);

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

@@ -1,6 +1,10 @@
-import { SCHEMA } from "@smithy/core/schema";
 import { fromUtf8 } from "@smithy/util-utf8";
 export class EventStreamSerde {
+    marshaller;
+    serializer;
+    deserializer;
+    serdeContext;
+    defaultContentType;
     constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) {
         this.marshaller = marshaller;
         this.serializer = serializer;
@@ -123,12 +127,15 @@ export class EventStreamSerde {
         let eventType = unionMember;
         let explicitPayloadMember = null;
         let explicitPayloadContentType;
-        const isKnownSchema = unionSchema.hasMemberSchema(unionMember);
+        const isKnownSchema = (() => {
+            const struct = unionSchema.getSchema();
+            return struct.memberNames.includes(unionMember);
+        })();
         const additionalHeaders = {};
         if (!isKnownSchema) {
             const [type, value] = event[unionMember];
             eventType = type;
-            serializer.write(SCHEMA.DOCUMENT, value);
+            serializer.write(15, value);
         }
         else {
             const eventSchema = unionSchema.getMemberSchema(unionMember);

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

@@ -1,4 +1,4 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
 import { splitEvery, splitHeader } from "@smithy/core/serde";
 import { HttpRequest } from "@smithy/protocol-http";
 import { sdkStreamMixin } from "@smithy/util-stream";
@@ -31,7 +31,7 @@ export class HttpBindingProtocol extends HttpProtocol {
         if (endpoint) {
             this.updateServiceEndpoint(request, endpoint);
             this.setHostPrefix(request, operationSchema, input);
-            const opTraits = NormalizedSchema.translateTraits(operationSchema.traits);
+            const opTraits = translateTraits(operationSchema.traits);
             if (opTraits.http) {
                 request.method = opTraits.http[0];
                 const [path, search] = opTraits.http[1].split("?");
@@ -155,7 +155,7 @@ export class HttpBindingProtocol extends HttpProtocol {
         if (response.statusCode >= 300) {
             const bytes = await collectBody(response.body, context);
             if (bytes.byteLength > 0) {
-                Object.assign(dataObject, await deserializer.read(SCHEMA.DOCUMENT, bytes));
+                Object.assign(dataObject, await deserializer.read(15, bytes));
             }
             await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
             throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
@@ -221,7 +221,7 @@ export class HttpBindingProtocol extends HttpProtocol {
                         headerListValueSchema.getMergedTraits().httpHeader = key;
                         let sections;
                         if (headerListValueSchema.isTimestampSchema() &&
-                            headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
+                            headerListValueSchema.getSchema() === 4) {
                             sections = splitEvery(value, ",", 2);
                         }
                         else {

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

@@ -1,7 +1,10 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
-export class HttpProtocol {
+import { SerdeContext } from "./SerdeContext";
+export class HttpProtocol extends SerdeContext {
+    options;
     constructor(options) {
+        super();
         this.options = options;
     }
     getRequestType() {
@@ -27,10 +30,10 @@ export class HttpProtocol {
             request.fragment = endpoint.url.hash || void 0;
             request.username = endpoint.url.username || void 0;
             request.password = endpoint.url.password || void 0;
+            if (!request.query) {
+                request.query = {};
+            }
             for (const [k, v] of endpoint.url.searchParams.entries()) {
-                if (!request.query) {
-                    request.query = {};
-                }
                 request.query[k] = v;
             }
             return request;

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

@@ -1,4 +1,4 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { NormalizedSchema } from "@smithy/core/schema";
 import { HttpRequest } from "@smithy/protocol-http";
 import { collectBody } from "./collect-stream-body";
 import { HttpProtocol } from "./HttpProtocol";
@@ -64,7 +64,7 @@ export class RpcProtocol extends HttpProtocol {
         if (response.statusCode >= 300) {
             const bytes = await collectBody(response.body, context);
             if (bytes.byteLength > 0) {
-                Object.assign(dataObject, await deserializer.read(SCHEMA.DOCUMENT, bytes));
+                Object.assign(dataObject, await deserializer.read(15, bytes));
             }
             await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
             throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");

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

@@ -0,0 +1,6 @@
+export class SerdeContext {
+    serdeContext;
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+}

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

@@ -10,3 +10,4 @@ export * from "./serde/HttpInterceptingShapeDeserializer";
 export * from "./serde/HttpInterceptingShapeSerializer";
 export * from "./serde/ToStringShapeSerializer";
 export * from "./serde/determineTimestampFormat";
+export * from "./SerdeContext";

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

@@ -4,16 +4,18 @@ export function requestBuilder(input, context) {
     return new RequestBuilder(input, context);
 }
 export class RequestBuilder {
+    input;
+    context;
+    query = {};
+    method = "";
+    headers = {};
+    path = "";
+    body = null;
+    hostname = "";
+    resolvePathStack = [];
     constructor(input, context) {
         this.input = input;
         this.context = context;
-        this.query = {};
-        this.method = "";
-        this.headers = {};
-        this.path = "";
-        this.body = null;
-        this.hostname = "";
-        this.resolvePathStack = [];
     }
     async build() {
         const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();

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

@@ -1,15 +1,15 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
-import { LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, splitHeader, } from "@smithy/core/serde";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, LazyJsonString, NumericValue, splitHeader, } from "@smithy/core/serde";
 import { fromBase64 } from "@smithy/util-base64";
 import { toUtf8 } from "@smithy/util-utf8";
+import { SerdeContext } from "../SerdeContext";
 import { determineTimestampFormat } from "./determineTimestampFormat";
-export class FromStringShapeDeserializer {
+export class FromStringShapeDeserializer extends SerdeContext {
+    settings;
     constructor(settings) {
+        super();
         this.settings = settings;
     }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
     read(_schema, data) {
         const ns = NormalizedSchema.of(_schema);
         if (ns.isListSchema()) {
@@ -21,12 +21,12 @@ export class FromStringShapeDeserializer {
         if (ns.isTimestampSchema()) {
             const format = determineTimestampFormat(ns, this.settings);
             switch (format) {
-                case SCHEMA.TIMESTAMP_DATE_TIME:
-                    return parseRfc3339DateTimeWithOffset(data);
-                case SCHEMA.TIMESTAMP_HTTP_DATE:
-                    return parseRfc7231DateTime(data);
-                case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
-                    return parseEpochTimestamp(data);
+                case 5:
+                    return _parseRfc3339DateTimeWithOffset(data);
+                case 6:
+                    return _parseRfc7231DateTime(data);
+                case 7:
+                    return _parseEpochTimestamp(data);
                 default:
                     console.warn("Missing timestamp format, parsing value with Date constructor:", data);
                     return new Date(data);
@@ -46,15 +46,17 @@ export class FromStringShapeDeserializer {
                 return intermediateValue;
             }
         }
-        switch (true) {
-            case ns.isNumericSchema():
-                return Number(data);
-            case ns.isBigIntegerSchema():
-                return BigInt(data);
-            case ns.isBigDecimalSchema():
-                return new NumericValue(data, "bigDecimal");
-            case ns.isBooleanSchema():
-                return String(data).toLowerCase() === "true";
+        if (ns.isNumericSchema()) {
+            return Number(data);
+        }
+        if (ns.isBigIntegerSchema()) {
+            return BigInt(data);
+        }
+        if (ns.isBigDecimalSchema()) {
+            return new NumericValue(data, "bigDecimal");
+        }
+        if (ns.isBooleanSchema()) {
+            return String(data).toLowerCase() === "true";
         }
         return data;
     }

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

@@ -1,8 +1,12 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { SerdeContext } from "../SerdeContext";
 import { FromStringShapeDeserializer } from "./FromStringShapeDeserializer";
-export class HttpInterceptingShapeDeserializer {
+export class HttpInterceptingShapeDeserializer extends SerdeContext {
+    codecDeserializer;
+    stringDeserializer;
     constructor(codecDeserializer, codecSettings) {
+        super();
         this.codecDeserializer = codecDeserializer;
         this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
     }

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

@@ -1,6 +1,9 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { ToStringShapeSerializer } from "./ToStringShapeSerializer";
 export class HttpInterceptingShapeSerializer {
+    codecSerializer;
+    stringSerializer;
+    buffer;
     constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
         this.codecSerializer = codecSerializer;
         this.stringSerializer = stringSerializer;

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

@@ -1,15 +1,14 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { NormalizedSchema } from "@smithy/core/schema";
 import { dateToUtcString, LazyJsonString, quoteHeader } from "@smithy/core/serde";
 import { toBase64 } from "@smithy/util-base64";
+import { SerdeContext } from "../SerdeContext";
 import { determineTimestampFormat } from "./determineTimestampFormat";
-export class ToStringShapeSerializer {
+export class ToStringShapeSerializer extends SerdeContext {
+    settings;
+    stringBuffer = "";
     constructor(settings) {
+        super();
         this.settings = settings;
-        this.stringBuffer = "";
-        this.serdeContext = undefined;
-    }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
     }
     write(schema, value) {
         const ns = NormalizedSchema.of(schema);
@@ -25,13 +24,13 @@ export class ToStringShapeSerializer {
                     }
                     const format = determineTimestampFormat(ns, this.settings);
                     switch (format) {
-                        case SCHEMA.TIMESTAMP_DATE_TIME:
+                        case 5:
                             this.stringBuffer = value.toISOString().replace(".000Z", "Z");
                             break;
-                        case SCHEMA.TIMESTAMP_HTTP_DATE:
+                        case 6:
                             this.stringBuffer = dateToUtcString(value);
                             break;
-                        case SCHEMA.TIMESTAMP_EPOCH_SECONDS:
+                        case 7:
                             this.stringBuffer = String(value.getTime() / 1000);
                             break;
                         default:

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

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

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

@@ -1,4 +1,8 @@
 export class TypeRegistry {
+    namespace;
+    schemas;
+    exceptions;
+    static registries = new Map();
     constructor(namespace, schemas = new Map(), exceptions = new Map()) {
         this.namespace = namespace;
         this.schemas = schemas;
@@ -21,11 +25,11 @@ export class TypeRegistry {
         }
         return this.schemas.get(id);
     }
-    registerError(errorSchema, ctor) {
-        this.exceptions.set(errorSchema, ctor);
+    registerError(es, ctor) {
+        this.exceptions.set(es, ctor);
     }
-    getErrorCtor(errorSchema) {
-        return this.exceptions.get(errorSchema);
+    getErrorCtor(es) {
+        return this.exceptions.get(es);
     }
     getBaseException() {
         for (const [id, schema] of this.schemas.entries()) {
@@ -52,4 +56,3 @@ export class TypeRegistry {
         return this.normalizeShapeId(shapeId).split("#")[0];
     }
 }
-TypeRegistry.registries = new Map();

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

@@ -9,4 +9,5 @@ export * from "./schemas/Schema";
 export * from "./schemas/SimpleSchema";
 export * from "./schemas/StructureSchema";
 export * from "./schemas/sentinels";
+export * from "./schemas/translateTraits";
 export * from "./TypeRegistry";

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

@@ -1,8 +1,12 @@
 import { HttpResponse } from "@smithy/protocol-http";
 import { getSmithyContext } from "@smithy/util-middleware";
+import { hydrate, isStaticSchema } from "../schemas/NormalizedSchema";
 export const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
     const { response } = await next(args);
-    const { operationSchema } = getSmithyContext(context);
+    let { operationSchema } = getSmithyContext(context);
+    if (isStaticSchema(operationSchema)) {
+        operationSchema = hydrate(operationSchema);
+    }
     try {
         const parsed = await config.protocol.deserializeResponse(operationSchema, {
             ...config,

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

@@ -1,6 +1,10 @@
 import { getSmithyContext } from "@smithy/util-middleware";
+import { hydrate, isStaticSchema } from "../schemas/NormalizedSchema";
 export const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-    const { operationSchema } = getSmithyContext(context);
+    let { operationSchema } = getSmithyContext(context);
+    if (isStaticSchema(operationSchema)) {
+        operationSchema = hydrate(operationSchema);
+    }
     const endpoint = context.endpointV2?.url && config.urlParser
         ? async () => config.urlParser(context.endpointV2.url)
         : config.endpoint;

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

@@ -1,12 +1,10 @@
 import { Schema } from "./Schema";
 import { StructureSchema } from "./StructureSchema";
 export class ErrorSchema extends StructureSchema {
-    constructor() {
-        super(...arguments);
-        this.symbol = ErrorSchema.symbol;
-    }
+    static symbol = Symbol.for("@smithy/err");
+    ctor;
+    symbol = ErrorSchema.symbol;
 }
-ErrorSchema.symbol = Symbol.for("@smithy/err");
 export const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
     name,
     namespace,

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

@@ -1,11 +1,11 @@
 import { Schema } from "./Schema";
 export class ListSchema extends Schema {
-    constructor() {
-        super(...arguments);
-        this.symbol = ListSchema.symbol;
-    }
+    static symbol = Symbol.for("@smithy/lis");
+    name;
+    traits;
+    valueSchema;
+    symbol = ListSchema.symbol;
 }
-ListSchema.symbol = Symbol.for("@smithy/lis");
 export const list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema(), {
     name,
     namespace,