@mavogel/awscdk-rootmail 0.0.323 → 0.0.324

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

@@ -1,10 +1,12 @@
 import { deref } from "../deref";
-import { ListSchema } from "./ListSchema";
-import { MapSchema } from "./MapSchema";
+import { error } from "./ErrorSchema";
+import { list, ListSchema } from "./ListSchema";
+import { map, MapSchema } from "./MapSchema";
+import { op } from "./OperationSchema";
 import { Schema } from "./Schema";
-import { SCHEMA } from "./sentinels";
-import { SimpleSchema } from "./SimpleSchema";
-import { StructureSchema } from "./StructureSchema";
+import { sim } from "./SimpleSchema";
+import { struct, StructureSchema } from "./StructureSchema";
+import { translateTraits } from "./translateTraits";
 export class NormalizedSchema {
     ref;
     memberName;
@@ -23,17 +25,19 @@ export class NormalizedSchema {
         let _ref = ref;
         let schema = ref;
         this._isMemberSchema = false;
-        while (Array.isArray(_ref)) {
+        while (isMemberSchema(_ref)) {
             traitStack.push(_ref[1]);
             _ref = _ref[0];
             schema = deref(_ref);
             this._isMemberSchema = true;
         }
+        if (isStaticSchema(schema))
+            schema = hydrate(schema);
         if (traitStack.length > 0) {
             this.memberTraits = {};
             for (let i = traitStack.length - 1; i >= 0; --i) {
                 const traitSet = traitStack[i];
-                Object.assign(this.memberTraits, NormalizedSchema.translateTraits(traitSet));
+                Object.assign(this.memberTraits, translateTraits(traitSet));
             }
         }
         else {
@@ -54,8 +58,7 @@ export class NormalizedSchema {
         else {
             this.traits = 0;
         }
-        this.name =
-            (this.schema instanceof Schema ? this.schema.getName?.() : void 0) ?? this.memberName ?? this.getSchemaName();
+        this.name = (this.schema instanceof Schema ? this.schema.getName?.() : void 0) ?? this.memberName ?? String(schema);
         if (this._isMemberSchema && !memberName) {
             throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
         }
@@ -64,138 +67,90 @@ export class NormalizedSchema {
         return Schema[Symbol.hasInstance].bind(this)(lhs);
     }
     static of(ref) {
-        if (ref instanceof NormalizedSchema) {
-            return ref;
+        const sc = deref(ref);
+        if (sc instanceof NormalizedSchema) {
+            return sc;
         }
-        if (Array.isArray(ref)) {
-            const [ns, traits] = ref;
+        if (isMemberSchema(sc)) {
+            const [ns, traits] = sc;
             if (ns instanceof NormalizedSchema) {
-                Object.assign(ns.getMergedTraits(), NormalizedSchema.translateTraits(traits));
+                Object.assign(ns.getMergedTraits(), translateTraits(traits));
                 return ns;
             }
             throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
         }
-        return new NormalizedSchema(ref);
-    }
-    static translateTraits(indicator) {
-        if (typeof indicator === "object") {
-            return indicator;
-        }
-        indicator = indicator | 0;
-        const traits = {};
-        let i = 0;
-        for (const trait of [
-            "httpLabel",
-            "idempotent",
-            "idempotencyToken",
-            "sensitive",
-            "httpPayload",
-            "httpResponseCode",
-            "httpQueryParams",
-        ]) {
-            if (((indicator >> i++) & 1) === 1) {
-                traits[trait] = 1;
-            }
-        }
-        return traits;
+        return new NormalizedSchema(sc);
     }
     getSchema() {
-        if (this.schema instanceof NormalizedSchema) {
-            Object.assign(this, { schema: this.schema.getSchema() });
-            return this.schema;
-        }
-        if (this.schema instanceof SimpleSchema) {
-            return deref(this.schema.schemaRef);
-        }
-        return deref(this.schema);
+        return deref(this.schema?.schemaRef ?? this.schema);
     }
     getName(withNamespace = false) {
-        if (!withNamespace) {
-            if (this.name && this.name.includes("#")) {
-                return this.name.split("#")[1];
-            }
-        }
-        return this.name || undefined;
+        const { name } = this;
+        const short = !withNamespace && name && name.includes("#");
+        return short ? name.split("#")[1] : name || undefined;
     }
     getMemberName() {
-        if (!this.isMemberSchema()) {
-            throw new Error(`@smithy/core/schema - non-member schema: ${this.getName(true)}`);
-        }
         return this.memberName;
     }
     isMemberSchema() {
         return this._isMemberSchema;
     }
-    isUnitSchema() {
-        return this.getSchema() === "unit";
-    }
     isListSchema() {
-        const inner = this.getSchema();
-        if (typeof inner === "number") {
-            return inner >= SCHEMA.LIST_MODIFIER && inner < SCHEMA.MAP_MODIFIER;
-        }
-        return inner instanceof ListSchema;
+        const sc = this.getSchema();
+        return typeof sc === "number"
+            ? sc >= 64 && sc < 128
+            : sc instanceof ListSchema;
     }
     isMapSchema() {
-        const inner = this.getSchema();
-        if (typeof inner === "number") {
-            return inner >= SCHEMA.MAP_MODIFIER && inner <= 0b1111_1111;
-        }
-        return inner instanceof MapSchema;
+        const sc = this.getSchema();
+        return typeof sc === "number"
+            ? sc >= 128 && sc <= 0b1111_1111
+            : sc instanceof MapSchema;
     }
     isStructSchema() {
-        const inner = this.getSchema();
-        return (inner !== null && typeof inner === "object" && "members" in inner) || inner instanceof StructureSchema;
+        const sc = this.getSchema();
+        return (sc !== null && typeof sc === "object" && "members" in sc) || sc instanceof StructureSchema;
     }
     isBlobSchema() {
-        return this.getSchema() === SCHEMA.BLOB || this.getSchema() === SCHEMA.STREAMING_BLOB;
+        const sc = this.getSchema();
+        return sc === 21 || sc === 42;
     }
     isTimestampSchema() {
-        const schema = this.getSchema();
-        return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
+        const sc = this.getSchema();
+        return (typeof sc === "number" &&
+            sc >= 4 &&
+            sc <= 7);
+    }
+    isUnitSchema() {
+        return this.getSchema() === "unit";
     }
     isDocumentSchema() {
-        return this.getSchema() === SCHEMA.DOCUMENT;
+        return this.getSchema() === 15;
     }
     isStringSchema() {
-        return this.getSchema() === SCHEMA.STRING;
+        return this.getSchema() === 0;
     }
     isBooleanSchema() {
-        return this.getSchema() === SCHEMA.BOOLEAN;
+        return this.getSchema() === 2;
     }
     isNumericSchema() {
-        return this.getSchema() === SCHEMA.NUMERIC;
+        return this.getSchema() === 1;
     }
     isBigIntegerSchema() {
-        return this.getSchema() === SCHEMA.BIG_INTEGER;
+        return this.getSchema() === 17;
     }
     isBigDecimalSchema() {
-        return this.getSchema() === SCHEMA.BIG_DECIMAL;
+        return this.getSchema() === 19;
     }
     isStreaming() {
-        const streaming = !!this.getMergedTraits().streaming;
-        if (streaming) {
-            return true;
-        }
-        return this.getSchema() === SCHEMA.STREAMING_BLOB;
+        const { streaming } = this.getMergedTraits();
+        return !!streaming || this.getSchema() === 42;
     }
     isIdempotencyToken() {
-        if (this.normalizedTraits) {
-            return !!this.normalizedTraits.idempotencyToken;
-        }
-        for (const traits of [this.traits, this.memberTraits]) {
-            if (typeof traits === "number") {
-                if ((traits & 0b0100) === 0b0100) {
-                    return true;
-                }
-            }
-            else if (typeof traits === "object") {
-                if (!!traits.idempotencyToken) {
-                    return true;
-                }
-            }
-        }
-        return false;
+        const match = (traits) => (traits & 0b0100) === 0b0100 ||
+            !!traits?.idempotencyToken;
+        const { normalizedTraits, traits, memberTraits } = this;
+        return match(normalizedTraits) || match(traits) || match(memberTraits);
     }
     getMergedTraits() {
         return (this.normalizedTraits ??
@@ -205,74 +160,48 @@ export class NormalizedSchema {
             }));
     }
     getMemberTraits() {
-        return NormalizedSchema.translateTraits(this.memberTraits);
+        return translateTraits(this.memberTraits);
     }
     getOwnTraits() {
-        return NormalizedSchema.translateTraits(this.traits);
+        return translateTraits(this.traits);
     }
     getKeySchema() {
-        if (this.isDocumentSchema()) {
-            return this.memberFrom([SCHEMA.DOCUMENT, 0], "key");
-        }
-        if (!this.isMapSchema()) {
+        const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()];
+        if (!isDoc && !isMap) {
             throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
         }
         const schema = this.getSchema();
-        if (typeof schema === "number") {
-            return this.memberFrom([0b0011_1111 & schema, 0], "key");
-        }
-        return this.memberFrom([schema.keySchema, 0], "key");
+        const memberSchema = isDoc
+            ? 15
+            : schema?.keySchema ?? 0;
+        return member([memberSchema, 0], "key");
     }
     getValueSchema() {
-        const schema = this.getSchema();
-        if (typeof schema === "number") {
-            if (this.isMapSchema()) {
-                return this.memberFrom([0b0011_1111 & schema, 0], "value");
-            }
-            else if (this.isListSchema()) {
-                return this.memberFrom([0b0011_1111 & schema, 0], "member");
-            }
-        }
-        if (schema && typeof schema === "object") {
-            if (this.isStructSchema()) {
-                throw new Error(`may not getValueSchema() on structure ${this.getName(true)}`);
-            }
-            const collection = schema;
-            if ("valueSchema" in collection) {
-                if (this.isMapSchema()) {
-                    return this.memberFrom([collection.valueSchema, 0], "value");
-                }
-                else if (this.isListSchema()) {
-                    return this.memberFrom([collection.valueSchema, 0], "member");
-                }
-            }
-        }
-        if (this.isDocumentSchema()) {
-            return this.memberFrom([SCHEMA.DOCUMENT, 0], "value");
+        const sc = this.getSchema();
+        const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()];
+        const memberSchema = typeof sc === "number"
+            ? 0b0011_1111 & sc
+            : sc && typeof sc === "object" && (isMap || isList)
+                ? sc.valueSchema
+                : isDoc
+                    ? 15
+                    : void 0;
+        if (memberSchema != null) {
+            return member([memberSchema, 0], isMap ? "value" : "member");
         }
         throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
     }
-    hasMemberSchema(member) {
-        if (this.isStructSchema()) {
-            const struct = this.getSchema();
-            return struct.memberNames.includes(member);
-        }
-        return false;
-    }
-    getMemberSchema(member) {
-        if (this.isStructSchema()) {
-            const struct = this.getSchema();
-            if (!struct.memberNames.includes(member)) {
-                throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${member}.`);
-            }
-            const i = struct.memberNames.indexOf(member);
+    getMemberSchema(memberName) {
+        const struct = this.getSchema();
+        if (this.isStructSchema() && struct.memberNames.includes(memberName)) {
+            const i = struct.memberNames.indexOf(memberName);
             const memberSchema = struct.memberList[i];
-            return this.memberFrom(Array.isArray(memberSchema) ? memberSchema : [memberSchema, 0], member);
+            return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
         }
         if (this.isDocumentSchema()) {
-            return this.memberFrom([SCHEMA.DOCUMENT, 0], member);
+            return member([15, 0], memberName);
         }
-        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no members.`);
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
     }
     getMemberSchemas() {
         const buffer = {};
@@ -303,35 +232,30 @@ export class NormalizedSchema {
         }
         const struct = this.getSchema();
         for (let i = 0; i < struct.memberNames.length; ++i) {
-            yield [struct.memberNames[i], this.memberFrom([struct.memberList[i], 0], struct.memberNames[i])];
-        }
-    }
-    memberFrom(memberSchema, memberName) {
-        if (memberSchema instanceof NormalizedSchema) {
-            return Object.assign(memberSchema, {
-                memberName,
-                _isMemberSchema: true,
-            });
+            yield [struct.memberNames[i], member([struct.memberList[i], 0], struct.memberNames[i])];
         }
-        return new NormalizedSchema(memberSchema, memberName);
-    }
-    getSchemaName() {
-        const schema = this.getSchema();
-        if (typeof schema === "number") {
-            const _schema = 0b0011_1111 & schema;
-            const container = 0b1100_0000 & schema;
-            const type = Object.entries(SCHEMA).find(([, value]) => {
-                return value === _schema;
-            })?.[0] ?? "Unknown";
-            switch (container) {
-                case SCHEMA.MAP_MODIFIER:
-                    return `${type}Map`;
-                case SCHEMA.LIST_MODIFIER:
-                    return `${type}List`;
-                case 0:
-                    return type;
-            }
-        }
-        return "Unknown";
     }
 }
+function member(memberSchema, memberName) {
+    if (memberSchema instanceof NormalizedSchema) {
+        return Object.assign(memberSchema, {
+            memberName,
+            _isMemberSchema: true,
+        });
+    }
+    const internalCtorAccess = NormalizedSchema;
+    return new internalCtorAccess(memberSchema, memberName);
+}
+export function hydrate(ss) {
+    const [id, ...rest] = ss;
+    return {
+        [0]: sim,
+        [1]: list,
+        [2]: map,
+        [3]: struct,
+        [-3]: error,
+        [9]: op,
+    }[id].call(null, ...rest);
+}
+const isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+export const isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;

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

@@ -0,0 +1,22 @@
+export function translateTraits(indicator) {
+    if (typeof indicator === "object") {
+        return indicator;
+    }
+    indicator = indicator | 0;
+    const traits = {};
+    let i = 0;
+    for (const trait of [
+        "httpLabel",
+        "idempotent",
+        "idempotencyToken",
+        "sensitive",
+        "httpPayload",
+        "httpResponseCode",
+        "httpQueryParams",
+    ]) {
+        if (((indicator >> i++) & 1) === 1) {
+            traits[trait] = 1;
+        }
+    }
+    return traits;
+}

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

@@ -4,6 +4,7 @@ export * from "./generateIdempotencyToken";
 export * from "./lazy-json";
 export * from "./parse-utils";
 export * from "./quote-header";
+export * from "./schema-serde-lib/schema-date-utils";
 export * from "./split-every";
 export * from "./split-header";
 export * from "./value/NumericValue";

package/node_modules/@smithy/core/dist-es/submodules/serde/schema-serde-lib/schema-date-utils.js

@@ -0,0 +1,110 @@
+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"];
+export 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));
+};
+export 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;
+};
+export 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}]`);
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js

@@ -1,25 +1,12 @@
+const format = /^-?\d*(\.\d+)?$/;
 export 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() {
@@ -30,16 +17,7 @@ export 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));
     }
 }
 export function nv(input) {

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

@@ -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-types/submodules/cbor/CborCodec.d.ts

@@ -1,20 +1,17 @@
-import type { Codec, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { SerdeContext } from "@smithy/core/protocols";
+import type { Codec, Schema, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
 /**
  * @alpha
  */
-export declare class CborCodec implements Codec<Uint8Array, Uint8Array> {
-    private serdeContext?;
+export declare class CborCodec extends SerdeContext implements Codec<Uint8Array, Uint8Array> {
     createSerializer(): CborShapeSerializer;
     createDeserializer(): CborShapeDeserializer;
-    setSerdeContext(serdeContext: SerdeFunctions): void;
 }
 /**
  * @alpha
  */
-export declare class CborShapeSerializer implements ShapeSerializer {
-    private serdeContext?;
+export declare class CborShapeSerializer extends SerdeContext implements ShapeSerializer {
     private value;
-    setSerdeContext(serdeContext: SerdeFunctions): void;
     write(schema: Schema, value: unknown): void;
     /**
      * Recursive serializer transform that copies and prepares the user input object
@@ -26,9 +23,7 @@ export declare class CborShapeSerializer implements ShapeSerializer {
 /**
  * @alpha
  */
-export declare class CborShapeDeserializer implements ShapeDeserializer {
-    private serdeContext?;
-    setSerdeContext(serdeContext: SerdeFunctions): void;
+export declare class CborShapeDeserializer extends SerdeContext implements ShapeDeserializer {
     read(schema: Schema, bytes: Uint8Array): any;
     /**
      * Public because it's called by the protocol implementation to deserialize errors.

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

@@ -1,18 +1,18 @@
 import type { EventStreamSerde } from "@smithy/core/event-streams";
 import { NormalizedSchema } from "@smithy/core/schema";
 import type { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, EventStreamMarshaller, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { SerdeContext } from "./SerdeContext";
 /**
  * Abstract base for HTTP-based client protocols.
  *
  * @alpha
  */
-export declare abstract class HttpProtocol implements ClientProtocol<IHttpRequest, IHttpResponse> {
+export declare abstract class HttpProtocol extends SerdeContext implements ClientProtocol<IHttpRequest, IHttpResponse> {
     readonly options: {
         defaultNamespace: string;
     };
     protected abstract serializer: ShapeSerializer<string | Uint8Array>;
     protected abstract deserializer: ShapeDeserializer<string | Uint8Array>;
-    protected serdeContext?: SerdeFunctions;
     protected constructor(options: {
         defaultNamespace: string;
     });
@@ -20,6 +20,9 @@ export declare abstract class HttpProtocol implements ClientProtocol<IHttpReques
     abstract getPayloadCodec(): Codec<any, any>;
     getRequestType(): new (...args: any[]) => IHttpRequest;
     getResponseType(): new (...args: any[]) => IHttpResponse;
+    /**
+     * @override
+     */
     setSerdeContext(serdeContext: SerdeFunctions): void;
     abstract serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
     updateServiceEndpoint(request: IHttpRequest, endpoint: EndpointV2 | Endpoint): IHttpRequest;

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

@@ -0,0 +1,8 @@
+import type { ConfigurableSerdeContext, SerdeFunctions } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare abstract class SerdeContext implements ConfigurableSerdeContext {
+    protected serdeContext?: SerdeFunctions;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}