lambda-live-debugger 1.10.0 → 1.10.1

package/node_modules/@aws-sdk/client-iot-data-plane/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js

@@ -1,10 +1,12 @@
 import { HttpResponse } from "@smithy/protocol-http";
 import { getSmithyContext } from "@smithy/util-middleware";
+import { operation } from "../schemas/operation";
 export const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
     const { response } = await next(args);
     const { operationSchema } = getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
     try {
-        const parsed = await config.protocol.deserializeResponse(operationSchema, {
+        const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
             ...config,
             ...context,
         }, response);

package/node_modules/@aws-sdk/client-iot-data-plane/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js

@@ -1,10 +1,12 @@
 import { getSmithyContext } from "@smithy/util-middleware";
+import { operation } from "../schemas/operation";
 export const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
     const { operationSchema } = getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
     const endpoint = context.endpointV2?.url && config.urlParser
         ? async () => config.urlParser(context.endpointV2.url)
         : config.endpoint;
-    const request = await config.protocol.serializeRequest(operationSchema, args.input, {
+    const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
         ...config,
         ...context,
         endpoint,

package/node_modules/@aws-sdk/client-iot-data-plane/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js

@@ -1,10 +1,5 @@
 import { deref } from "../deref";
-import { ListSchema } from "./ListSchema";
-import { MapSchema } from "./MapSchema";
-import { Schema } from "./Schema";
-import { SCHEMA } from "./sentinels";
-import { SimpleSchema } from "./SimpleSchema";
-import { StructureSchema } from "./StructureSchema";
+import { translateTraits } from "./translateTraits";
 export class NormalizedSchema {
     ref;
     memberName;
@@ -23,7 +18,7 @@ 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);
@@ -33,7 +28,7 @@ export class NormalizedSchema {
             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 {
@@ -48,154 +43,116 @@ export class NormalizedSchema {
             return;
         }
         this.schema = deref(schema);
-        if (this.schema && typeof this.schema === "object") {
-            this.traits = this.schema?.traits ?? {};
+        if (isStaticSchema(this.schema)) {
+            this.name = `${this.schema[1]}#${this.schema[2]}`;
+            this.traits = this.schema[3];
         }
         else {
+            this.name = this.memberName ?? String(schema);
             this.traits = 0;
         }
-        this.name =
-            (this.schema instanceof Schema ? this.schema.getName?.() : void 0) ?? this.memberName ?? this.getSchemaName();
         if (this._isMemberSchema && !memberName) {
             throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
         }
     }
     static [Symbol.hasInstance](lhs) {
-        return Schema[Symbol.hasInstance].bind(this)(lhs);
+        const isPrototype = this.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const ns = lhs;
+            return ns.symbol === this.symbol;
+        }
+        return isPrototype;
     }
     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);
+        const sc = this.schema;
+        if (sc[0] === 0) {
+            return sc[4];
         }
-        return deref(this.schema);
+        return sc;
     }
     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[0] === 1;
     }
     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[0] === 2;
     }
     isStructSchema() {
-        const inner = this.getSchema();
-        return (inner !== null && typeof inner === "object" && "members" in inner) || inner instanceof StructureSchema;
+        const sc = this.getSchema();
+        return (sc[0] === 3 ||
+            sc[0] === -3);
     }
     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 +162,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[4] ?? 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[3 + sc[0]]
+                : 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);
-            const memberSchema = struct.memberList[i];
-            return this.memberFrom(Array.isArray(memberSchema) ? memberSchema : [memberSchema, 0], member);
+    getMemberSchema(memberName) {
+        const struct = this.getSchema();
+        if (this.isStructSchema() && struct[4].includes(memberName)) {
+            const i = struct[4].indexOf(memberName);
+            const memberSchema = struct[5][i];
+            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 = {};
@@ -302,36 +233,20 @@ export class NormalizedSchema {
             throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
         }
         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,
-            });
-        }
-        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;
-            }
+        for (let i = 0; i < struct[4].length; ++i) {
+            yield [struct[4][i], member([struct[5][i], 0], struct[4][i])];
         }
-        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);
+}
+const isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+export const isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;

package/node_modules/@aws-sdk/client-iot-data-plane/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js

@@ -1,11 +1,9 @@
-import { TypeRegistry } from "../TypeRegistry";
 export class Schema {
     name;
     namespace;
     traits;
     static assign(instance, values) {
         const schema = Object.assign(instance, values);
-        TypeRegistry.for(schema.namespace).register(schema.name, schema);
         return schema;
     }
     static [Symbol.hasInstance](lhs) {

package/node_modules/@aws-sdk/client-iot-data-plane/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js

@@ -12,3 +12,9 @@ export const sim = (namespace, name, schemaRef, traits) => Schema.assign(new Sim
     traits,
     schemaRef,
 });
+export const simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+});

package/node_modules/@aws-sdk/client-iot-data-plane/node_modules/@smithy/core/dist-es/submodules/schema/schemas/operation.js

@@ -0,0 +1,7 @@
+export const operation = (namespace, name, traits, input, output) => ({
+    name,
+    namespace,
+    traits,
+    input,
+    output,
+});

package/node_modules/@aws-sdk/client-iot-data-plane/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/@aws-sdk/client-iot-data-plane/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/@aws-sdk/client-iot-data-plane/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/@aws-sdk/client-iot-data-plane/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/@aws-sdk/client-iot-data-plane/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";