@cdk8s/awscdk-resolver 0.0.710 → 0.0.712

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

@@ -0,0 +1,121 @@
+import { NumericValue } from "@smithy/core/serde";
+export function jsonReviver(key, value, context) {
+    if (context?.source) {
+        const numericString = context.source;
+        if (typeof value === "number") {
+            const inSafeRange = value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER;
+            if (inSafeRange) {
+                if (isRepresentable(numericString, value)) {
+                    return value;
+                }
+                return new NumericValue(numericString, "bigDecimal");
+            }
+            else {
+                if (isFractionalBigNumeric(numericString)) {
+                    return new NumericValue(numericString, "bigDecimal");
+                }
+                if (/[eE]/.test(numericString)) {
+                    return expandExponentToBigInt(numericString);
+                }
+                return BigInt(numericString);
+            }
+        }
+    }
+    return value;
+}
+function isFractionalBigNumeric(s) {
+    const dotIndex = s.indexOf(".");
+    if (dotIndex === -1) {
+        return false;
+    }
+    const eIndex = s.search(/[eE]/);
+    if (eIndex === -1) {
+        return true;
+    }
+    const fracDigits = eIndex - dotIndex - 1;
+    const exp = parseInt(s.slice(eIndex + 1), 10);
+    return exp < fracDigits;
+}
+function isRepresentable(numericString, value) {
+    if (numericString === String(value)) {
+        return true;
+    }
+    if (Object.is(value, -0)) {
+        return true;
+    }
+    if (/[eE]/.test(numericString)) {
+        return expandToDecimal(numericString) === expandToDecimal(String(value));
+    }
+    const normalized = numericString.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+    const canonical = String(value);
+    if (normalized === canonical) {
+        return true;
+    }
+    if (/[eE]/.test(canonical)) {
+        return normalized === expandToDecimal(canonical);
+    }
+    return false;
+}
+function expandToDecimal(s) {
+    const negative = s.startsWith("-");
+    const abs = negative ? s.slice(1) : s;
+    const eIndex = abs.search(/[eE]/);
+    let result;
+    if (eIndex === -1) {
+        result = abs;
+    }
+    else {
+        const exp = parseInt(abs.slice(eIndex + 1), 10);
+        const mantissa = abs.slice(0, eIndex);
+        const dotIndex = mantissa.indexOf(".");
+        let digits;
+        let intLen;
+        if (dotIndex === -1) {
+            digits = mantissa;
+            intLen = mantissa.length;
+        }
+        else {
+            digits = mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1);
+            intLen = dotIndex;
+        }
+        digits = digits.replace(/0+$/, "") || "0";
+        const newDotPos = intLen + exp;
+        if (digits === "0") {
+            result = "0";
+        }
+        else if (newDotPos <= 0) {
+            result = "0." + "0".repeat(-newDotPos) + digits;
+        }
+        else if (newDotPos >= digits.length) {
+            result = digits + "0".repeat(newDotPos - digits.length);
+        }
+        else {
+            result = digits.slice(0, newDotPos) + "." + digits.slice(newDotPos);
+        }
+    }
+    if (result.includes(".")) {
+        result = result.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+    }
+    return (negative ? "-" : "") + result;
+}
+function expandExponentToBigInt(s) {
+    const eIndex = s.search(/[eE]/);
+    const exp = parseInt(s.slice(eIndex + 1), 10);
+    const negative = s.startsWith("-");
+    const mantissa = s.slice(negative ? 1 : 0, eIndex);
+    const dotIndex = mantissa.indexOf(".");
+    let digits;
+    let shift;
+    if (dotIndex === -1) {
+        digits = mantissa;
+        shift = exp;
+    }
+    else {
+        digits = mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1);
+        const fracDigits = mantissa.length - dotIndex - 1;
+        shift = exp - fracDigits;
+    }
+    digits = digits.replace(/0+$/, "") || "0";
+    const result = BigInt(digits) * 10n ** BigInt(shift + (mantissa.replace(".", "").length - digits.length));
+    return negative ? -result : result;
+}

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

@@ -0,0 +1,41 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+const REVIVER_SYMBOL = Symbol.for("@aws-sdk/reviver");
+export function needsReviver(schema) {
+    const ns = NormalizedSchema.of(schema);
+    const raw = ns.getSchema();
+    if (Array.isArray(raw) && ns.isStructSchema()) {
+        if (REVIVER_SYMBOL in raw) {
+            return raw[REVIVER_SYMBOL];
+        }
+        const result = _check(ns, new Set());
+        raw[REVIVER_SYMBOL] = result;
+        return result;
+    }
+    return _check(ns, new Set());
+}
+function _check(ns, seen) {
+    const raw = ns.getSchema();
+    if (seen.has(raw)) {
+        return false;
+    }
+    seen.add(raw);
+    if (ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
+        return true;
+    }
+    if (ns.isStructSchema()) {
+        for (const [, memberSchema] of ns.structIterator()) {
+            if (_check(memberSchema, seen)) {
+                return true;
+            }
+        }
+    }
+    else if (ns.isListSchema() || ns.isMapSchema()) {
+        if (_check(ns.getValueSchema(), seen)) {
+            return true;
+        }
+    }
+    else if (ns.isDocumentSchema()) {
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,104 @@
+import { collectBody } from "../collect-stream-body";
+import { collectBodyString } from "../common";
+import { detectBufferParsing } from "./detectBufferParsing";
+import { jsonReviver } from "./jsonReviver";
+import { needsReviver } from "./needsReviver";
+export async function parseJsonBody(streamBody, context, schema) {
+    let parsingInput;
+    if (detectBufferParsing() && typeof streamBody?.[Symbol.asyncIterator] === "function") {
+        const buffer = await collectBody(streamBody, context);
+        if (typeof Buffer === "function") {
+            if (Buffer.isBuffer(buffer)) {
+                parsingInput = buffer;
+            }
+            else {
+                parsingInput = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            }
+        }
+    }
+    if (!parsingInput) {
+        parsingInput = await collectBodyString(streamBody, context);
+    }
+    if (parsingInput.length === 0) {
+        return {};
+    }
+    const reviver = schema && needsReviver(schema) ? jsonReviver : undefined;
+    try {
+        return JSON.parse(parsingInput, reviver);
+    }
+    catch (e) {
+        if (e?.name === "SyntaxError") {
+            Object.defineProperty(e, "$responseBodyText", {
+                value: typeof parsingInput === "string" ? parsingInput : parsingInput.toString("utf8"),
+            });
+        }
+        throw e;
+    }
+}
+export const parseJsonErrorBody = async (errorBody, context) => {
+    const value = await parseJsonBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+const sanitizeErrorCode = (rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+        cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+        cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+        cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+        cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+};
+export const loadRestJsonErrorCode = (output, data) => {
+    return loadErrorCode(output, data, ["header", "code", "type"]);
+};
+export const loadJsonRpcErrorCode = (output, data, queryCompat = false) => {
+    return loadErrorCode(output, data, queryCompat ? ["code", "header", "type"] : ["type", "code", "header"]);
+};
+export const loadSmithyRpcV2JsonErrorCode = (output, data) => {
+    if (data?.__type !== undefined) {
+        let cleanValue = data.__type;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        return cleanValue;
+    }
+};
+const loadErrorCode = ({ headers }, data, order) => {
+    while (order.length > 0) {
+        const location = order.shift();
+        switch (location) {
+            case "header":
+                const headerKey = findKey(headers ?? {}, "x-amzn-errortype");
+                if (headerKey !== undefined) {
+                    return sanitizeErrorCode(headers[headerKey]);
+                }
+                break;
+            case "code":
+                const codeKey = findKey(data ?? {}, "code");
+                if (codeKey && data[codeKey] !== undefined) {
+                    return sanitizeErrorCode(data[codeKey]);
+                }
+                break;
+            case "type":
+                if (data?.__type !== undefined) {
+                    return sanitizeErrorCode(data.__type);
+                }
+                break;
+        }
+    }
+};

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

@@ -0,0 +1,3 @@
+export function writeKey(obj) {
+    Object.defineProperty(obj, "__proto__", { value: undefined, writable: true, enumerable: true, configurable: true });
+}

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

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

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

@@ -0,0 +1,24 @@
+/**
+ * Helper for identifying unknown union members during deserialization.
+ */
+export declare class UnionSerde {
+    private from;
+    private to;
+    private keys;
+    constructor(from: any, to: any);
+    /**
+     * Marks the key as being a known member.
+     * @param key - to mark.
+     */
+    mark(key: string): void;
+    /**
+     * @returns whether only one key remains unmarked and nothing has been written,
+     * implying the object is a union.
+     */
+    hasUnknown(): boolean;
+    /**
+     * Writes the unknown key-value pair, if present, into the $unknown property
+     * of the union object.
+     */
+    writeUnknown(): void;
+}

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

@@ -0,0 +1,2 @@
+import type { SerdeFunctions } from "@smithy/types";
+export declare const collectBodyString: (streamBody: any, context: SerdeFunctions) => Promise<string>;

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

@@ -25,3 +25,12 @@ export { escapeUriPath } from "./util-uri-escape/escape-uri-path";
 export { buildQueryString } from "./querystring-builder/buildQueryString";
 export { parseQueryString } from "@smithy/core/transport";
 export { parseUrl } from "@smithy/core/transport";
+export { SmithyRpcV2JsonProtocol } from "./json/SmithyRpcV2JsonProtocol";
+export { parseJsonBody, parseJsonErrorBody, loadJsonRpcErrorCode, loadRestJsonErrorCode, loadSmithyRpcV2JsonErrorCode, } from "./json/parseJsonBody";
+export type { JsonSettings } from "./json/JsonSettings";
+export { JsonCodec } from "./json/codec-v1/JsonCodec";
+export { JsonShapeSerializer } from "./json/codec-v1/JsonShapeSerializer";
+export { JsonShapeDeserializer } from "./json/codec-v1/JsonShapeDeserializer";
+export { JsonCodec2 } from "./json/codec-v2/JsonCodec2";
+export { JsonShapeSerializer2 } from "./json/codec-v2/JsonShapeSerializer2";
+export { JsonShapeDeserializer2 } from "./json/codec-v2/JsonShapeDeserializer2";

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

@@ -0,0 +1,13 @@
+import type { CodecSettings } from "@smithy/types";
+/**
+ * @public
+ */
+export type JsonSettings = CodecSettings & {
+    jsonName: boolean;
+    /**
+     * When true, bigInteger and bigDecimal values are serialized as JSON strings
+     * to preserve arbitrary precision (Smithy RPCv2 JSON behavior). When false or
+     * unset, they are serialized as unquoted JSON numbers (AWS JSON 1.0/1.1 behavior).
+     */
+    bigNumberAsString?: boolean;
+};

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

@@ -0,0 +1,28 @@
+import { RpcProtocol } from "../RpcProtocol";
+import { TypeRegistry } from "@smithy/core/schema";
+import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { JsonCodec2 } from "./codec-v2/JsonCodec2";
+/**
+ * Client protocol for Smithy RPCv2 JSON.
+ *
+ * @public
+ */
+export declare class SmithyRpcV2JsonProtocol extends RpcProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    private codec;
+    protected serializer: ShapeSerializer<string | Uint8Array>;
+    protected deserializer: ShapeDeserializer<string | Uint8Array>;
+    constructor({ defaultNamespace, errorTypeRegistries, }: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    getShapeId(): string;
+    getPayloadCodec(): JsonCodec2;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected getDefaultContentType(): string;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v1/JsonCodec.d.ts

@@ -0,0 +1,15 @@
+import type { Codec } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonShapeDeserializer } from "./JsonShapeDeserializer";
+import { JsonShapeSerializer } from "./JsonShapeSerializer";
+import type { JsonSettings } from "./JsonSettings";
+/**
+ * @deprecated use JsonCodec2.
+ * @public
+ */
+export declare class JsonCodec extends SerdeContextConfig implements Codec<string, string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    createSerializer(): JsonShapeSerializer;
+    createDeserializer(): JsonShapeDeserializer;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v1/JsonSettings.d.ts

@@ -0,0 +1,7 @@
+import type { CodecSettings } from "@smithy/types";
+/**
+ * @public
+ */
+export type JsonSettings = CodecSettings & {
+    jsonName: boolean;
+};

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v1/JsonShapeDeserializer.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import type { JsonSettings } from "./JsonSettings";
+/**
+ * @deprecated prefer JsonShapeDeserializer in codec-v2.
+ * @public
+ */
+export declare class JsonShapeDeserializer extends SerdeContextConfig implements ShapeDeserializer<string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    read(schema: Schema, data: string | Uint8Array | unknown): Promise<any>;
+    readObject(schema: Schema, data: DocumentType): any;
+    protected _read(schema: Schema, value: unknown): any;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v1/JsonShapeSerializer.d.ts

@@ -0,0 +1,29 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import type { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import type { JsonSettings } from "./JsonSettings";
+/**
+ * @deprecated prefer byte-targeting JsonShapeSerializer or its string adapter StringJsonShapeSerializer in codec-v2.
+ * @public
+ */
+export declare class JsonShapeSerializer extends SerdeContextConfig implements ShapeSerializer<string> {
+    readonly settings: JsonSettings;
+    /**
+     * Write buffer. Reused per value serialization pass.
+     * In the initial implementation, this is not an incremental buffer.
+     */
+    protected buffer: any;
+    protected useReplacer: boolean;
+    protected rootSchema: NormalizedSchema | undefined;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    flush(): string;
+    /**
+     * @internal
+     */
+    writeDiscriminatedDocument(schema: Schema, value: unknown): void;
+    /**
+     * Order if-statements by likelihood.
+     */
+    protected _write(schema: Schema, value: unknown, container?: NormalizedSchema): any;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v2/JsonBytesStringAdapter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A Uint8Array subclass holding serialized JSON bytes that provides
+ * string method compatibility for customer middleware.
+ *
+ * Middleware historically observed `request.body` as a string for JSON
+ * protocol services. This class preserves that contract: string methods
+ * and coercion (template literals, `+` operator) lazily decode the bytes
+ * to a cached string. The HTTP transport layer still sees a Uint8Array
+ * and sends raw bytes without conversion.
+ *
+ * @internal
+ * @deprecated this adapter will be removed in a future version.
+ */
+export declare class JsonBytesStringAdapter extends Uint8Array {
+    private string;
+    static allocUnsafe(bytes: number): JsonBytesStringAdapter;
+    /**
+     * Enables string coercion via template literals and `+` operator.
+     */
+    toString(): string;
+    /**
+     * Enables string coercion in comparison and arithmetic contexts.
+     * @returns a string. The signature is set to avoid incompatibility with extending Uint8Array.
+     */
+    valueOf(): any;
+    includes(searchString: string | number, position?: number): boolean;
+    indexOf(searchString: string | number, position?: number): number;
+    lastIndexOf(searchString: string | number, position?: number): number;
+    startsWith(searchString: string, position?: number): boolean;
+    endsWith(searchString: string, endPosition?: number): boolean;
+    match(regexp: string | RegExp): RegExpMatchArray | null;
+    replace(searchValue: string | RegExp, replaceValue: string): string;
+    search(regexp: string | RegExp): number;
+    split(separator: string | RegExp, limit?: number): string[];
+    substring(start: number, end?: number): string;
+    trim(): string;
+    trimStart(): string;
+    trimEnd(): string;
+    charAt(pos: number): string;
+    charCodeAt(index: number): number;
+    padStart(maxLength: number, fillString?: string): string;
+    padEnd(maxLength: number, fillString?: string): string;
+    repeat(count: number): string;
+    toUpperCase(): string;
+    toLowerCase(): string;
+    /**
+     * Decodes the bytes to a UTF-8 string on first access, then caches.
+     * Subsequent calls return the cached string with zero cost.
+     */
+    private s;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v2/JsonCodec2.d.ts

@@ -0,0 +1,13 @@
+import type { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import type { JsonSettings } from "../JsonSettings";
+/**
+ * Codec grouping the v2 serializer and deserializer.
+ * @public
+ */
+export declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    createSerializer(): $ShapeSerializer<Uint8Array>;
+    createDeserializer(): $ShapeDeserializer<string>;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v2/JsonShapeDeserializer2.d.ts

@@ -0,0 +1,30 @@
+import type { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import type { JsonSettings } from "../JsonSettings";
+/**
+ * Performance-optimized JSON deserializer.
+ *
+ * Skips UTF-8 decoding when the runtime supports JSON.parse(Buffer) (Node 22+).
+ *
+ * After JSON.parse, lists, maps, and document containers are mutated in place
+ * (element values are overwritten with their deserialized form) rather than
+ * copied into new arrays/objects. Structs allocate a fresh object because
+ * jsonName traits require key renaming, and building the output object
+ * incrementally lets V8 assign a stable hidden class rather than
+ * deoptimizing from repeated property deletion/addition on an existing shape.
+ *
+ * In-place mutation is safe here because the parsed tree is locally owned
+ * after JSON.parse with no external references, so rewriting values avoids
+ * redundant allocation and GC pressure.
+ *
+ * @public
+ */
+export declare class JsonShapeDeserializer2 extends SerdeContextConfig implements ShapeDeserializer<string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    read(schema: Schema, data: string | Uint8Array | unknown): Promise<any>;
+    readObject(schema: Schema, data: DocumentType): any;
+    protected _read(schema: Schema, value: unknown): any;
+    private _readStruct;
+    private needsTransform;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/json/codec-v2/JsonShapeSerializer2.d.ts

@@ -0,0 +1,60 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import type { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import type { JsonSettings } from "../JsonSettings";
+/**
+ * Single-pass JSON serializer that writes directly to a Uint8Array buffer.
+ * Fewer intermediate states as when compared to the initial multi-pass implementation.
+ *
+ * @public
+ */
+export declare class JsonShapeSerializer2 extends SerdeContextConfig implements ShapeSerializer<Uint8Array> {
+    readonly settings: JsonSettings;
+    private json;
+    private i;
+    private rootSchema;
+    private rawValue;
+    private passthrough;
+    constructor(settings: JsonSettings);
+    write(schema: Schema, value: unknown): void;
+    /**
+     * @internal
+     */
+    writeDiscriminatedDocument(schema: Schema, value: unknown): void;
+    /**
+     * Returns the serialized JSON as a Uint8Array (UTF-8 bytes).
+     * This is the primary output — pass directly to request.body.
+     */
+    flush(): Uint8Array;
+    protected ensure(byteCount: number): void;
+    /**
+     * Write a raw ASCII string (no JSON escaping). Used for pre-validated content
+     * like numeric literals and pre-encoded base64.
+     */
+    protected writeAscii(s: string): void;
+    /**
+     * Write a quoted ASCII string with no escape checking.
+     * Used for struct member keys (jsonName or model names) which are
+     * guaranteed to be safe ASCII identifiers. No control chars, quotes,
+     * backslashes, or non-ASCII.
+     * Ensures extra room for surrounding structural chars (comma, colon).
+     */
+    protected writeAsciiQuoted(s: string): void;
+    /**
+     * Write a JSON-escaped string including the surrounding quotes.
+     * Fast-path for ASCII, falls back to TextEncoder for multi-byte.
+     */
+    protected writeJsonString(s: string): void;
+    protected writeUnicodeEscape(code: number): void;
+    protected static readonly B64: Uint8Array;
+    /**
+     * Write a Uint8Array as a quoted base64 string directly into the buffer.
+     * No intermediate JS string, no escape checking (base64 alphabet is safe ASCII).
+     */
+    protected writeBase64(data: Uint8Array): void;
+    protected writeValue(schema: Schema, value: unknown, container: NormalizedSchema | undefined): void;
+    protected writeStruct(ns: NormalizedSchema, value: Record<string, unknown>): void;
+    protected writeList(ns: NormalizedSchema, value: unknown[], isDocument?: boolean): void;
+    protected writeMap(ns: NormalizedSchema, value: Record<string, unknown>, isDocument?: boolean): void;
+    protected writeTimestamp(ns: NormalizedSchema, value: Date): void;
+}

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

@@ -0,0 +1 @@
+export declare function detectBufferParsing(): boolean;

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

@@ -0,0 +1,21 @@
+/**
+ * Serializes BigInt and NumericValue to JSON-number.
+ * @internal
+ */
+export declare class JsonReplacer {
+    /**
+     * Stores placeholder key to true serialized value lookup.
+     */
+    private readonly values;
+    private counter;
+    private stage;
+    /**
+     * Creates a jsonReplacer function that reserves big integer and big decimal values
+     * for later replacement.
+     */
+    createReplacer(): (key: string, value: unknown) => unknown;
+    /**
+     * Replaces placeholder keys with their true values.
+     */
+    replaceInJson(json: string): string;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @param key - JSON object key.
+ * @param value - parsed value.
+ * @param context - original JSON string for reference. Not available until Node.js 21 and unavailable in Safari as
+ * of April 2025.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#browser_compatibility
+ *
+ * @internal
+ *
+ * @returns transformed value.
+ */
+export declare function jsonReviver(key: string, value: any, context?: {
+    source?: string;
+}): any;

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

@@ -0,0 +1,11 @@
+import type { Schema } from "@smithy/types";
+/**
+ * Determines whether a schema tree contains BigInteger or BigDecimal members,
+ * which require a JSON.parse reviver to preserve numeric precision.
+ *
+ * The result is cached on the root static schema array (struct schemas) via a Symbol key,
+ * so subsequent calls for the same schema are O(1).
+ *
+ * @internal
+ */
+export declare function needsReviver(schema: Schema): boolean;