@gemeentenijmegen/webapp 1.1.9 → 1.1.11

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

@@ -1,10 +1,15 @@
 import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { splitEvery, splitHeader } from "@smithy/core/serde";
 import { HttpRequest } from "@smithy/protocol-http";
+import { sdkStreamMixin } from "@smithy/util-stream";
 import { collectBody } from "./collect-stream-body";
 import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
 import { HttpProtocol } from "./HttpProtocol";
 export class HttpBindingProtocol extends HttpProtocol {
-    async serializeRequest(operationSchema, input, context) {
+    async serializeRequest(operationSchema, _input, context) {
+        const input = {
+            ...(_input ?? {}),
+        };
         const serializer = this.serializer;
         const query = {};
         const headers = {};
@@ -40,16 +45,12 @@ export class HttpBindingProtocol extends HttpProtocol {
                 Object.assign(query, Object.fromEntries(traitSearchParams));
             }
         }
-        const _input = {
-            ...input,
-        };
-        for (const memberName of Object.keys(_input)) {
-            const memberNs = ns.getMemberSchema(memberName);
-            if (memberNs === undefined) {
+        for (const [memberName, memberNs] of ns.structIterator()) {
+            const memberTraits = memberNs.getMergedTraits() ?? {};
+            const inputMemberValue = input[memberName];
+            if (inputMemberValue == null) {
                 continue;
             }
-            const memberTraits = memberNs.getMergedTraits();
-            const inputMember = _input[memberName];
             if (memberTraits.httpPayload) {
                 const isStreaming = memberNs.isStreaming();
                 if (isStreaming) {
@@ -58,16 +59,17 @@ export class HttpBindingProtocol extends HttpProtocol {
                         throw new Error("serialization of event streams is not yet implemented");
                     }
                     else {
-                        payload = inputMember;
+                        payload = inputMemberValue;
                     }
                 }
                 else {
-                    serializer.write(memberNs, inputMember);
+                    serializer.write(memberNs, inputMemberValue);
                     payload = serializer.flush();
                 }
+                delete input[memberName];
             }
             else if (memberTraits.httpLabel) {
-                serializer.write(memberNs, inputMember);
+                serializer.write(memberNs, inputMemberValue);
                 const replacement = serializer.flush();
                 if (request.path.includes(`{${memberName}+}`)) {
                     request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/"));
@@ -75,31 +77,31 @@ export class HttpBindingProtocol extends HttpProtocol {
                 else if (request.path.includes(`{${memberName}}`)) {
                     request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement));
                 }
-                delete _input[memberName];
+                delete input[memberName];
             }
             else if (memberTraits.httpHeader) {
-                serializer.write(memberNs, inputMember);
+                serializer.write(memberNs, inputMemberValue);
                 headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
-                delete _input[memberName];
+                delete input[memberName];
             }
             else if (typeof memberTraits.httpPrefixHeaders === "string") {
-                for (const [key, val] of Object.entries(inputMember)) {
+                for (const [key, val] of Object.entries(inputMemberValue)) {
                     const amalgam = memberTraits.httpPrefixHeaders + key;
                     serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
                     headers[amalgam.toLowerCase()] = serializer.flush();
                 }
-                delete _input[memberName];
+                delete input[memberName];
             }
             else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
-                this.serializeQuery(memberNs, inputMember, query);
-                delete _input[memberName];
+                this.serializeQuery(memberNs, inputMemberValue, query);
+                delete input[memberName];
             }
             else {
                 hasNonHttpBindingMember = true;
             }
         }
         if (hasNonHttpBindingMember && input) {
-            serializer.write(schema, _input);
+            serializer.write(schema, input);
             payload = serializer.flush();
         }
         request.headers = headers;
@@ -175,4 +177,97 @@ export class HttpBindingProtocol extends HttpProtocol {
         };
         return output;
     }
+    async deserializeHttpMessage(schema, context, response, arg4, arg5) {
+        let dataObject;
+        if (arg4 instanceof Set) {
+            dataObject = arg5;
+        }
+        else {
+            dataObject = arg4;
+        }
+        const deserializer = this.deserializer;
+        const ns = NormalizedSchema.of(schema);
+        const nonHttpBindingMembers = [];
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+            const memberTraits = memberSchema.getMemberTraits();
+            if (memberTraits.httpPayload) {
+                const isStreaming = memberSchema.isStreaming();
+                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,
+                                };
+                            }
+                        });
+                    }
+                    else {
+                        dataObject[memberName] = sdkStreamMixin(response.body);
+                    }
+                }
+                else if (response.body) {
+                    const bytes = await collectBody(response.body, context);
+                    if (bytes.byteLength > 0) {
+                        dataObject[memberName] = await deserializer.read(memberSchema, bytes);
+                    }
+                }
+            }
+            else if (memberTraits.httpHeader) {
+                const key = String(memberTraits.httpHeader).toLowerCase();
+                const value = response.headers[key];
+                if (null != value) {
+                    if (memberSchema.isListSchema()) {
+                        const headerListValueSchema = memberSchema.getValueSchema();
+                        let sections;
+                        if (headerListValueSchema.isTimestampSchema() &&
+                            headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
+                            sections = splitEvery(value, ",", 2);
+                        }
+                        else {
+                            sections = splitHeader(value);
+                        }
+                        const list = [];
+                        for (const section of sections) {
+                            list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], section.trim()));
+                        }
+                        dataObject[memberName] = list;
+                    }
+                    else {
+                        dataObject[memberName] = await deserializer.read(memberSchema, value);
+                    }
+                }
+            }
+            else if (memberTraits.httpPrefixHeaders !== undefined) {
+                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);
+                    }
+                }
+            }
+            else if (memberTraits.httpResponseCode) {
+                dataObject[memberName] = response.statusCode;
+            }
+            else {
+                nonHttpBindingMembers.push(memberName);
+            }
+        }
+        return nonHttpBindingMembers;
+    }
 }

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

@@ -1,8 +1,5 @@
-import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
-import { splitEvery, splitHeader } from "@smithy/core/serde";
+import { NormalizedSchema } from "@smithy/core/schema";
 import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
-import { sdkStreamMixin } from "@smithy/util-stream";
-import { collectBody } from "./collect-stream-body";
 export class HttpProtocol {
     constructor(options) {
         this.options = options;
@@ -76,96 +73,11 @@ export class HttpProtocol {
         };
     }
     async deserializeHttpMessage(schema, context, response, arg4, arg5) {
-        let dataObject;
-        if (arg4 instanceof Set) {
-            dataObject = arg5;
-        }
-        else {
-            dataObject = arg4;
-        }
-        const deserializer = this.deserializer;
-        const ns = NormalizedSchema.of(schema);
-        const nonHttpBindingMembers = [];
-        for (const [memberName, memberSchema] of ns.structIterator()) {
-            const memberTraits = memberSchema.getMemberTraits();
-            if (memberTraits.httpPayload) {
-                const isStreaming = memberSchema.isStreaming();
-                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,
-                                };
-                            }
-                        });
-                    }
-                    else {
-                        dataObject[memberName] = sdkStreamMixin(response.body);
-                    }
-                }
-                else if (response.body) {
-                    const bytes = await collectBody(response.body, context);
-                    if (bytes.byteLength > 0) {
-                        dataObject[memberName] = await deserializer.read(memberSchema, bytes);
-                    }
-                }
-            }
-            else if (memberTraits.httpHeader) {
-                const key = String(memberTraits.httpHeader).toLowerCase();
-                const value = response.headers[key];
-                if (null != value) {
-                    if (memberSchema.isListSchema()) {
-                        const headerListValueSchema = memberSchema.getValueSchema();
-                        let sections;
-                        if (headerListValueSchema.isTimestampSchema() &&
-                            headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
-                            sections = splitEvery(value, ",", 2);
-                        }
-                        else {
-                            sections = splitHeader(value);
-                        }
-                        const list = [];
-                        for (const section of sections) {
-                            list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], section.trim()));
-                        }
-                        dataObject[memberName] = list;
-                    }
-                    else {
-                        dataObject[memberName] = await deserializer.read(memberSchema, value);
-                    }
-                }
-            }
-            else if (memberTraits.httpPrefixHeaders !== undefined) {
-                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);
-                    }
-                }
-            }
-            else if (memberTraits.httpResponseCode) {
-                dataObject[memberName] = response.statusCode;
-            }
-            else {
-                nonHttpBindingMembers.push(memberName);
-            }
-        }
-        return nonHttpBindingMembers;
+        void schema;
+        void context;
+        void response;
+        void arg4;
+        void arg5;
+        return [];
     }
 }

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

@@ -8,8 +8,18 @@ export class ErrorSchema extends StructureSchema {
         this.memberNames = memberNames;
         this.memberList = memberList;
         this.ctor = ctor;
+        this.symbol = ErrorSchema.symbol;
+    }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = ErrorSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const err = lhs;
+            return err.symbol === ErrorSchema.symbol;
+        }
+        return isPrototype;
     }
 }
+ErrorSchema.symbol = Symbol.for("@smithy/core/schema::ErrorSchema");
 export function error(namespace, name, traits = {}, memberNames, memberList, ctor) {
     const schema = new ErrorSchema(namespace + "#" + name, traits, memberNames, memberList, ctor);
     TypeRegistry.for(namespace).register(name, schema);

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

@@ -6,8 +6,18 @@ export class ListSchema extends Schema {
         this.name = name;
         this.traits = traits;
         this.valueSchema = valueSchema;
+        this.symbol = ListSchema.symbol;
+    }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = ListSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const list = lhs;
+            return list.symbol === ListSchema.symbol;
+        }
+        return isPrototype;
     }
 }
+ListSchema.symbol = Symbol.for("@smithy/core/schema::ListSchema");
 export function list(namespace, name, traits = {}, valueSchema) {
     const schema = new ListSchema(namespace + "#" + name, traits, typeof valueSchema === "function" ? valueSchema() : valueSchema);
     TypeRegistry.for(namespace).register(name, schema);

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

@@ -7,8 +7,18 @@ export class MapSchema extends Schema {
         this.traits = traits;
         this.keySchema = keySchema;
         this.valueSchema = valueSchema;
+        this.symbol = MapSchema.symbol;
+    }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = MapSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const map = lhs;
+            return map.symbol === MapSchema.symbol;
+        }
+        return isPrototype;
     }
 }
+MapSchema.symbol = Symbol.for("@smithy/core/schema::MapSchema");
 export function map(namespace, name, traits = {}, keySchema, valueSchema) {
     const schema = new MapSchema(namespace + "#" + name, traits, keySchema, typeof valueSchema === "function" ? valueSchema() : valueSchema);
     TypeRegistry.for(namespace).register(name, schema);

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

@@ -8,6 +8,7 @@ export class NormalizedSchema {
     constructor(ref, memberName) {
         this.ref = ref;
         this.memberName = memberName;
+        this.symbol = NormalizedSchema.symbol;
         const traitStack = [];
         let _ref = ref;
         let schema = ref;
@@ -52,6 +53,14 @@ export class NormalizedSchema {
             throw new Error(`@smithy/core/schema - NormalizedSchema member schema ${this.getName(true)} must initialize with memberName argument.`);
         }
     }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = NormalizedSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const ns = lhs;
+            return ns.symbol === NormalizedSchema.symbol;
+        }
+        return isPrototype;
+    }
     static of(ref, memberName) {
         if (ref instanceof NormalizedSchema) {
             return ref;
@@ -174,6 +183,15 @@ export class NormalizedSchema {
         }
         return this.getSchema() === SCHEMA.STREAMING_BLOB;
     }
+    isIdempotencyToken() {
+        if (typeof this.traits === "number") {
+            return (this.traits & 0b0100) === 0b0100;
+        }
+        else if (typeof this.traits === "object") {
+            return !!this.traits.idempotencyToken;
+        }
+        return false;
+    }
     getMergedTraits() {
         if (this.normalizedTraits) {
             return this.normalizedTraits;
@@ -292,3 +310,4 @@ export class NormalizedSchema {
         return "Unknown";
     }
 }
+NormalizedSchema.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");

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

@@ -6,8 +6,18 @@ export class SimpleSchema extends Schema {
         this.name = name;
         this.schemaRef = schemaRef;
         this.traits = traits;
+        this.symbol = SimpleSchema.symbol;
+    }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = SimpleSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const sim = lhs;
+            return sim.symbol === SimpleSchema.symbol;
+        }
+        return isPrototype;
     }
 }
+SimpleSchema.symbol = Symbol.for("@smithy/core/schema::SimpleSchema");
 export function sim(namespace, name, schemaRef, traits) {
     const schema = new SimpleSchema(namespace + "#" + name, schemaRef, traits);
     TypeRegistry.for(namespace).register(name, schema);

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

@@ -7,6 +7,7 @@ export class StructureSchema extends Schema {
         this.traits = traits;
         this.memberNames = memberNames;
         this.memberList = memberList;
+        this.symbol = StructureSchema.symbol;
         this.members = {};
         for (let i = 0; i < memberNames.length; ++i) {
             this.members[memberNames[i]] = Array.isArray(memberList[i])
@@ -14,7 +15,16 @@ export class StructureSchema extends Schema {
                 : [memberList[i], 0];
         }
     }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = StructureSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const struct = lhs;
+            return struct.symbol === StructureSchema.symbol;
+        }
+        return isPrototype;
+    }
 }
+StructureSchema.symbol = Symbol.for("@smithy/core/schema::StructureSchema");
 export function struct(namespace, name, traits, memberNames, memberList) {
     const schema = new StructureSchema(namespace + "#" + name, traits, memberNames, memberList);
     TypeRegistry.for(namespace).register(name, schema);

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

@@ -1,53 +1 @@
-import { NormalizedSchema } from "@smithy/core/schema";
-export const copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => {
-    const ns = NormalizedSchema.of(schemaRef);
-    switch (typeof source) {
-        case "undefined":
-        case "boolean":
-        case "number":
-        case "string":
-        case "bigint":
-        case "symbol":
-            return transform(source, ns);
-        case "function":
-        case "object":
-            if (source === null) {
-                return transform(null, ns);
-            }
-            if (Array.isArray(source)) {
-                const newArray = new Array(source.length);
-                let i = 0;
-                for (const item of source) {
-                    newArray[i++] = copyDocumentWithTransform(item, ns.getValueSchema(), transform);
-                }
-                return transform(newArray, ns);
-            }
-            if ("byteLength" in source) {
-                const newBytes = new Uint8Array(source.byteLength);
-                newBytes.set(source, 0);
-                return transform(newBytes, ns);
-            }
-            if (source instanceof Date) {
-                return transform(source, ns);
-            }
-            const newObject = {};
-            if (ns.isMapSchema()) {
-                for (const key of Object.keys(source)) {
-                    newObject[key] = copyDocumentWithTransform(source[key], ns.getValueSchema(), transform);
-                }
-            }
-            else if (ns.isStructSchema()) {
-                for (const [key, memberSchema] of ns.structIterator()) {
-                    newObject[key] = copyDocumentWithTransform(source[key], memberSchema, transform);
-                }
-            }
-            else if (ns.isDocumentSchema()) {
-                for (const key of Object.keys(source)) {
-                    newObject[key] = copyDocumentWithTransform(source[key], ns.getValueSchema(), transform);
-                }
-            }
-            return transform(newObject, ns);
-        default:
-            return transform(source, ns);
-    }
-};
+export const copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => source;

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

@@ -0,0 +1,2 @@
+import { v4 as generateIdempotencyToken } from "uuid";
+export { generateIdempotencyToken };

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

@@ -1,5 +1,6 @@
 export * from "./copyDocumentWithTransform";
 export * from "./date-utils";
+export * from "./generateIdempotencyToken";
 export * from "./lazy-json";
 export * from "./parse-utils";
 export * from "./quote-header";

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

@@ -2,8 +2,42 @@ export class NumericValue {
     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 "-".`);
+            }
+        }
+    }
+    toString() {
+        return this.string;
+    }
+    static [Symbol.hasInstance](object) {
+        if (!object || typeof object !== "object") {
+            return false;
+        }
+        const _nv = object;
+        const prototypeMatch = NumericValue.prototype.isPrototypeOf(object.constructor?.prototype);
+        if (prototypeMatch) {
+            return prototypeMatch;
+        }
+        if (typeof _nv.string === "string" && typeof _nv.type === "string" && _nv.constructor?.name === "NumericValue") {
+            return true;
+        }
+        return prototypeMatch;
     }
 }
-export function nv(string) {
-    return new NumericValue(string, "bigDecimal");
+export function nv(input) {
+    return new NumericValue(String(input), "bigDecimal");
 }

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

@@ -16,6 +16,11 @@ export declare class CborShapeSerializer 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
+     * for CBOR serialization.
+     */
+    serialize(schema: Schema, source: unknown): any;
     flush(): Uint8Array;
 }
 /**

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

@@ -0,0 +1,6 @@
+/**
+ * Prints bytes as binary string with numbers.
+ * @param bytes - to print.
+ * @deprecated for testing only, do not use in runtime.
+ */
+export declare function printBytes(bytes: Uint8Array): string[];

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

@@ -1,6 +1,6 @@
 import { NormalizedSchema } from "@smithy/core/schema";
 import { HttpRequest } from "@smithy/protocol-http";
-import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, SerdeFunctions } from "@smithy/types";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, Schema, SerdeFunctions } from "@smithy/types";
 import { HttpProtocol } from "./HttpProtocol";
 /**
  * Base for HTTP-binding protocols. Downstream examples
@@ -9,7 +9,15 @@ import { HttpProtocol } from "./HttpProtocol";
  * @alpha
  */
 export declare abstract class HttpBindingProtocol extends HttpProtocol {
-    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, _input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
     protected serializeQuery(ns: NormalizedSchema, data: any, query: HttpRequest["query"]): void;
     deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    /**
+     * The base method ignores HTTP bindings.
+     *
+     * @deprecated (only this signature) use signature without headerBindings.
+     * @override
+     */
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any): Promise<string[]>;
 }

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

@@ -26,7 +26,9 @@ export declare abstract class HttpProtocol implements ClientProtocol<IHttpReques
     protected abstract handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
     protected deserializeMetadata(output: IHttpResponse): ResponseMetadata;
     /**
-     * @deprecated use signature without headerBindings.
+     * For HTTP binding protocols, this method is overridden in {@link HttpBindingProtocol}.
+     *
+     * @deprecated only use this for HTTP binding protocols.
      */
     protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
     protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any): Promise<string[]>;

package/node_modules/@smithy/core/dist-types/submodules/schema/schemas/ErrorSchema.d.ts

@@ -17,11 +17,14 @@ export declare class ErrorSchema extends StructureSchema {
      * Constructor for a modeled service exception class that extends Error.
      */
     ctor: any;
+    static symbol: symbol;
+    protected symbol: symbol;
     constructor(name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[], 
     /**
      * Constructor for a modeled service exception class that extends Error.
      */
     ctor: any);
+    static [Symbol.hasInstance](lhs: unknown): lhs is ErrorSchema;
 }
 /**
  * Factory for ErrorSchema, to reduce codegen output and register the schema.

package/node_modules/@smithy/core/dist-types/submodules/schema/schemas/ListSchema.d.ts

@@ -10,7 +10,10 @@ export declare class ListSchema extends Schema implements IListSchema {
     name: string;
     traits: SchemaTraits;
     valueSchema: SchemaRef;
+    static symbol: symbol;
+    protected symbol: symbol;
     constructor(name: string, traits: SchemaTraits, valueSchema: SchemaRef);
+    static [Symbol.hasInstance](lhs: unknown): lhs is ListSchema;
 }
 /**
  * Factory for ListSchema.