@jjrawlins/cdk-iam-policy-builder-helper 0.0.51 → 0.0.53

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

@@ -2,9 +2,8 @@ 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;
@@ -33,7 +32,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 {
@@ -54,8 +53,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 +62,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 (Array.isArray(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 +155,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(Array.isArray(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 +227,17 @@ 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,
-            });
-        }
-        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;
-            }
+            yield [struct.memberNames[i], member([struct.memberList[i], 0], struct.memberNames[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);
+}

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/submodules/schema/index.d.ts

@@ -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-types/submodules/schema/schemas/NormalizedSchema.d.ts

@@ -1,4 +1,4 @@
-import type { MemberSchema, NormalizedSchema as INormalizedSchema, Schema as ISchema, SchemaRef, SchemaTraits, SchemaTraitsObject } from "@smithy/types";
+import type { MemberSchema, NormalizedSchema as INormalizedSchema, Schema as ISchema, SchemaRef, SchemaTraitsObject } from "@smithy/types";
 /**
  * Wraps both class instances, numeric sentinel values, and member schema pairs.
  * Presents a consistent interface for interacting with polymorphic schema representations.
@@ -7,7 +7,7 @@ import type { MemberSchema, NormalizedSchema as INormalizedSchema, Schema as ISc
  */
 export declare class NormalizedSchema implements INormalizedSchema {
     readonly ref: SchemaRef;
-    private memberName?;
+    private readonly memberName?;
     static readonly symbol: unique symbol;
     protected readonly symbol: symbol;
     private readonly name;
@@ -26,11 +26,6 @@ export declare class NormalizedSchema implements INormalizedSchema {
      * Static constructor that attempts to avoid wrapping a NormalizedSchema within another.
      */
     static of(ref: SchemaRef): NormalizedSchema;
-    /**
-     * @param indicator - numeric indicator for preset trait combination.
-     * @returns equivalent trait object.
-     */
-    static translateTraits(indicator: SchemaTraits): SchemaTraitsObject;
     /**
      * @returns the underlying non-normalized schema.
      */
@@ -42,11 +37,9 @@ export declare class NormalizedSchema implements INormalizedSchema {
     getName(withNamespace?: boolean): string | undefined;
     /**
      * @returns the member name if the schema is a member schema.
-     * @throws Error when the schema isn't a member schema.
      */
     getMemberName(): string;
     isMemberSchema(): boolean;
-    isUnitSchema(): boolean;
     /**
      * boolean methods on this class help control flow in shape serialization and deserialization.
      */
@@ -55,6 +48,7 @@ export declare class NormalizedSchema implements INormalizedSchema {
     isStructSchema(): boolean;
     isBlobSchema(): boolean;
     isTimestampSchema(): boolean;
+    isUnitSchema(): boolean;
     isDocumentSchema(): boolean;
     isStringSchema(): boolean;
     isBooleanSchema(): boolean;
@@ -94,20 +88,15 @@ export declare class NormalizedSchema implements INormalizedSchema {
      * @throws Error if the schema is not a Map, List, nor Document.
      */
     getValueSchema(): NormalizedSchema;
-    /**
-     * @param member - to query.
-     * @returns whether there is a memberSchema with the given member name. False if not a structure (or union).
-     */
-    hasMemberSchema(member: string): boolean;
     /**
      * @returns the NormalizedSchema for the given member name. The returned instance will return true for `isMemberSchema()`
      * and will have the member name given.
-     * @param member - which member to retrieve and wrap.
+     * @param memberName - which member to retrieve and wrap.
      *
      * @throws Error if member does not exist or the schema is neither a document nor structure.
      * Note that errors are assumed to be structures and unions are considered structures for these purposes.
      */
-    getMemberSchema(member: string): NormalizedSchema;
+    getMemberSchema(memberName: string): NormalizedSchema;
     /**
      * This can be used for checking the members as a hashmap.
      * Prefer the structIterator method for iteration.
@@ -131,12 +120,4 @@ export declare class NormalizedSchema implements INormalizedSchema {
      * This avoids the overhead of calling Object.entries(ns.getMemberSchemas()).
      */
     structIterator(): Generator<[string, NormalizedSchema], undefined, undefined>;
-    /**
-     * Creates a normalized member schema from the given schema and member name.
-     */
-    private memberFrom;
-    /**
-     * @returns a last-resort human-readable name for the schema if it has no other identifiers.
-     */
-    private getSchemaName;
 }

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

@@ -2,6 +2,8 @@ import type { BigDecimalSchema, BigIntegerSchema, BlobSchema, BooleanSchema, Doc
 /**
  * Schema sentinel runtime values.
  * @alpha
+ *
+ * @deprecated use inline numbers with type annotation to save space.
  */
 export declare const SCHEMA: {
     BLOB: BlobSchema;

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

@@ -0,0 +1,7 @@
+import type { SchemaTraits, SchemaTraitsObject } from "@smithy/types";
+/**
+ * @internal
+ * @param indicator - numeric indicator for preset trait combination.
+ * @returns equivalent trait object.
+ */
+export declare function translateTraits(indicator: SchemaTraits): SchemaTraitsObject;

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

@@ -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";