@mavogel/awscdk-rootmail 0.0.323 → 0.0.324

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

@@ -269,7 +269,7 @@ const parseRfc3339DateTime = (value) => {
     const day = parseDateValue(dayStr, "day", 1, 31);
     return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
 };
-const RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
+const RFC3339_WITH_OFFSET$1 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
 const parseRfc3339DateTimeWithOffset = (value) => {
     if (value === null || value === undefined) {
         return undefined;
@@ -277,7 +277,7 @@ const parseRfc3339DateTimeWithOffset = (value) => {
     if (typeof value !== "string") {
         throw new TypeError("RFC-3339 date-times must be expressed as strings");
     }
-    const match = RFC3339_WITH_OFFSET.exec(value);
+    const match = RFC3339_WITH_OFFSET$1.exec(value);
     if (!match) {
         throw new TypeError("Invalid RFC-3339 date-time value");
     }
@@ -291,9 +291,9 @@ const parseRfc3339DateTimeWithOffset = (value) => {
     }
     return date;
 };
-const IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
-const RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
-const ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
+const IMF_FIXDATE$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+const RFC_850_DATE$1 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+const ASC_TIME$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
 const parseRfc7231DateTime = (value) => {
     if (value === null || value === undefined) {
         return undefined;
@@ -301,12 +301,12 @@ const parseRfc7231DateTime = (value) => {
     if (typeof value !== "string") {
         throw new TypeError("RFC-7231 date-times must be expressed as strings");
     }
-    let match = IMF_FIXDATE.exec(value);
+    let match = IMF_FIXDATE$1.exec(value);
     if (match) {
         const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
         return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
     }
-    match = RFC_850_DATE.exec(value);
+    match = RFC_850_DATE$1.exec(value);
     if (match) {
         const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
         return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
@@ -316,7 +316,7 @@ const parseRfc7231DateTime = (value) => {
             fractionalMilliseconds,
         }));
     }
-    match = ASC_TIME.exec(value);
+    match = ASC_TIME$1.exec(value);
     if (match) {
         const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
         return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
@@ -457,6 +457,117 @@ function quoteHeader(part) {
     return part;
 }
 
+const ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
+const mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
+const time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
+const date = `(\\d?\\d)`;
+const year = `(\\d{4})`;
+const RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
+const IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
+const RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
+const ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
+const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const _parseEpochTimestamp = (value) => {
+    if (value == null) {
+        return void 0;
+    }
+    let num = NaN;
+    if (typeof value === "number") {
+        num = value;
+    }
+    else if (typeof value === "string") {
+        if (!/^-?\d*\.?\d+$/.test(value)) {
+            throw new TypeError(`parseEpochTimestamp - numeric string invalid.`);
+        }
+        num = Number.parseFloat(value);
+    }
+    else if (typeof value === "object" && value.tag === 1) {
+        num = value.value;
+    }
+    if (isNaN(num) || Math.abs(num) === Infinity) {
+        throw new TypeError("Epoch timestamps must be valid finite numbers.");
+    }
+    return new Date(Math.round(num * 1000));
+};
+const _parseRfc3339DateTimeWithOffset = (value) => {
+    if (value == null) {
+        return void 0;
+    }
+    if (typeof value !== "string") {
+        throw new TypeError("RFC3339 timestamps must be strings");
+    }
+    const matches = RFC3339_WITH_OFFSET.exec(value);
+    if (!matches) {
+        throw new TypeError(`Invalid RFC3339 timestamp format ${value}`);
+    }
+    const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches;
+    range(monthStr, 1, 12);
+    range(dayStr, 1, 31);
+    range(hours, 0, 23);
+    range(minutes, 0, 59);
+    range(seconds, 0, 60);
+    const date = new Date();
+    date.setUTCFullYear(Number(yearStr), Number(monthStr) - 1, Number(dayStr));
+    date.setUTCHours(Number(hours));
+    date.setUTCMinutes(Number(minutes));
+    date.setUTCSeconds(Number(seconds));
+    date.setUTCMilliseconds(Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1000) : 0);
+    if (offsetStr.toUpperCase() != "Z") {
+        const [, sign, offsetH, offsetM] = /([+-])(\d\d):(\d\d)/.exec(offsetStr) || [void 0, "+", 0, 0];
+        const scalar = sign === "-" ? 1 : -1;
+        date.setTime(date.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1000 + Number(offsetM) * 60 * 1000));
+    }
+    return date;
+};
+const _parseRfc7231DateTime = (value) => {
+    if (value == null) {
+        return void 0;
+    }
+    if (typeof value !== "string") {
+        throw new TypeError("RFC7231 timestamps must be strings.");
+    }
+    let day;
+    let month;
+    let year;
+    let hour;
+    let minute;
+    let second;
+    let fraction;
+    let matches;
+    if ((matches = IMF_FIXDATE.exec(value))) {
+        [, day, month, year, hour, minute, second, fraction] = matches;
+    }
+    else if ((matches = RFC_850_DATE.exec(value))) {
+        [, day, month, year, hour, minute, second, fraction] = matches;
+        year = (Number(year) + 1900).toString();
+    }
+    else if ((matches = ASC_TIME.exec(value))) {
+        [, month, day, hour, minute, second, fraction, year] = matches;
+    }
+    if (year && second) {
+        const date = new Date();
+        date.setUTCFullYear(Number(year));
+        date.setUTCMonth(months.indexOf(month));
+        range(day, 1, 31);
+        date.setUTCDate(Number(day));
+        range(hour, 0, 23);
+        date.setUTCHours(Number(hour));
+        range(minute, 0, 59);
+        date.setUTCMinutes(Number(minute));
+        range(second, 0, 60);
+        date.setUTCSeconds(Number(second));
+        date.setUTCMilliseconds(fraction ? Math.round(parseFloat(`0.${fraction}`) * 1000) : 0);
+        return date;
+    }
+    throw new TypeError(`Invalid RFC7231 date-time value ${value}.`);
+};
+function range(v, min, max) {
+    const _v = Number(v);
+    if (_v < min || _v > max) {
+        throw new Error(`Value ${_v} out of range [${min}, ${max}]`);
+    }
+}
+
 function splitEvery(value, delimiter, numDelimiters) {
     if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
         throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
@@ -522,28 +633,15 @@ const splitHeader = (value) => {
     });
 };
 
+const format = /^-?\d*(\.\d+)?$/;
 class NumericValue {
     string;
     type;
     constructor(string, type) {
         this.string = string;
         this.type = type;
-        let dot = 0;
-        for (let i = 0; i < string.length; ++i) {
-            const char = string.charCodeAt(i);
-            if (i === 0 && char === 45) {
-                continue;
-            }
-            if (char === 46) {
-                if (dot) {
-                    throw new Error("@smithy/core/serde - NumericValue must contain at most one decimal point.");
-                }
-                dot = 1;
-                continue;
-            }
-            if (char < 48 || char > 57) {
-                throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`);
-            }
+        if (!format.test(string)) {
+            throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`);
         }
     }
     toString() {
@@ -554,16 +652,7 @@ class NumericValue {
             return false;
         }
         const _nv = object;
-        const prototypeMatch = NumericValue.prototype.isPrototypeOf(object);
-        if (prototypeMatch) {
-            return prototypeMatch;
-        }
-        if (typeof _nv.string === "string" &&
-            typeof _nv.type === "string" &&
-            _nv.constructor?.name?.endsWith("NumericValue")) {
-            return true;
-        }
-        return prototypeMatch;
+        return NumericValue.prototype.isPrototypeOf(object) || (_nv.type === "bigDecimal" && format.test(_nv.string));
     }
 }
 function nv(input) {
@@ -576,6 +665,9 @@ Object.defineProperty(exports, "generateIdempotencyToken", {
 });
 exports.LazyJsonString = LazyJsonString;
 exports.NumericValue = NumericValue;
+exports._parseEpochTimestamp = _parseEpochTimestamp;
+exports._parseRfc3339DateTimeWithOffset = _parseRfc3339DateTimeWithOffset;
+exports._parseRfc7231DateTime = _parseRfc7231DateTime;
 exports.copyDocumentWithTransform = copyDocumentWithTransform;
 exports.dateToUtcString = dateToUtcString;
 exports.expectBoolean = expectBoolean;

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,10 +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 {
-    serdeContext;
+export class CborCodec extends SerdeContext {
     createSerializer() {
         const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
@@ -15,16 +15,9 @@ export class CborCodec {
         deserializer.setSerdeContext(this.serdeContext);
         return deserializer;
     }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
 }
-export class CborShapeSerializer {
-    serdeContext;
+export class CborShapeSerializer extends SerdeContext {
     value;
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
     write(schema, value) {
         this.value = this.serialize(schema, value);
     }
@@ -98,11 +91,7 @@ export class CborShapeSerializer {
         return buffer;
     }
 }
-export class CborShapeDeserializer {
-    serdeContext;
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
+export class CborShapeDeserializer extends SerdeContext {
     read(schema, bytes) {
         const data = cbor.deserialize(bytes);
         return this.readValue(schema, data);
@@ -110,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/event-streams/EventStreamSerde.js

@@ -1,4 +1,3 @@
-import { SCHEMA } from "@smithy/core/schema";
 import { fromUtf8 } from "@smithy/util-utf8";
 export class EventStreamSerde {
     marshaller;
@@ -128,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,9 +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;
-    serdeContext;
     constructor(options) {
+        super();
         this.options = options;
     }
     getRequestType() {
@@ -29,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/serde/FromStringShapeDeserializer.js

@@ -1,17 +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;
-    serdeContext;
     constructor(settings) {
+        super();
         this.settings = settings;
     }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
     read(_schema, data) {
         const ns = NormalizedSchema.of(_schema);
         if (ns.isListSchema()) {
@@ -23,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);
@@ -48,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,11 +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;
-    serdeContext;
     constructor(codecDeserializer, codecSettings) {
+        super();
         this.codecDeserializer = codecDeserializer;
         this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
     }

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

@@ -1,17 +1,15 @@
-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 = "";
-    serdeContext = undefined;
     constructor(settings) {
+        super();
         this.settings = settings;
     }
-    setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-    }
     write(schema, value) {
         const ns = NormalizedSchema.of(schema);
         switch (typeof value) {
@@ -26,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

@@ -25,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()) {

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;