lambda-live-debugger 1.12.8 → 1.12.9

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/RpcProtocol.d.ts

@@ -13,4 +13,16 @@ export declare abstract class RpcProtocol extends HttpProtocol {
     protected compositeErrorRegistry: TypeRegistry;
     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>;
+    /**
+     * Determines whether a response status code indicates an error response that
+     * should be routed to {@link handleError} rather than deserialized as output.
+     *
+     * The default treats any status code of 300 or greater as an error,
+     * preserving the historical behavior for RPC-over-HTTP protocols. Subclasses
+     * whose specification is stricter SHOULD override this.
+     *
+     * @param statusCode - the HTTP response status code.
+     * @returns true if the response should be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
 }

package/node_modules/@smithy/core/dist-types/ts3.4/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/ts3.4/submodules/protocols/common.d.ts

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

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

@@ -3,6 +3,7 @@ export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
 export { HttpBindingProtocol } from "./HttpBindingProtocol";
 export { HttpProtocol } from "./HttpProtocol";
 export { RpcProtocol } from "./RpcProtocol";
+export { AbstractRpcV2Protocol } from "./AbstractRpcV2Protocol";
 export { RequestBuilder, requestBuilder } from "./requestBuilder";
 export { resolvedPath } from "./resolve-path";
 export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";
@@ -25,3 +26,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 { 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/ts3.4/submodules/protocols/json/JsonSettings.d.ts

@@ -0,0 +1,13 @@
+import { 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/ts3.4/submodules/protocols/json/SmithyRpcV2JsonProtocol.d.ts

@@ -0,0 +1,19 @@
+import { AbstractRpcV2Protocol } from "../AbstractRpcV2Protocol";
+import { HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, 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 AbstractRpcV2Protocol {
+    private codec;
+    protected serializer: ShapeSerializer<string | Uint8Array>;
+    protected deserializer: ShapeDeserializer<string | Uint8Array>;
+    getShapeId(): string;
+    getPayloadCodec(): JsonCodec2;
+    protected getSmithyProtocolHeaderValue(): string;
+    protected applyEmptyBody(request: IHttpRequest): void;
+    protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected getDefaultContentType(): string;
+}

package/node_modules/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/codec-v1/JsonCodec.d.ts

@@ -1,11 +1,15 @@
-import { Codec } from "@smithy/types";
-import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
-import { JsonShapeDeserializer } from "./JsonShapeDeserializer";
-import { JsonShapeSerializer } from "./JsonShapeSerializer";
-import { JsonSettings } from "./JsonSettings";
-export declare class JsonCodec extends SerdeContextConfig implements Codec<string, string> {
-  readonly settings: JsonSettings;
-  constructor(settings: JsonSettings);
-  createSerializer(): JsonShapeSerializer;
-  createDeserializer(): JsonShapeDeserializer;
-}
+import { Codec } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { JsonShapeDeserializer } from "./JsonShapeDeserializer";
+import { JsonShapeSerializer } from "./JsonShapeSerializer";
+import { 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/{@aws-sdk/core/dist-types/ts3.4/submodules/protocols/json → @smithy/core/dist-types/ts3.4/submodules/protocols/json/codec-v1}/JsonSettings.d.ts

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

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

@@ -0,0 +1,14 @@
+import { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { 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/ts3.4/submodules/protocols/json/codec-v1/JsonShapeSerializer.d.ts

@@ -0,0 +1,29 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { 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/ts3.4/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/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/codec-v2/JsonCodec2.d.ts

@@ -1,9 +1,13 @@
-import { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
-import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
-import { JsonSettings } from "../JsonSettings";
-export declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
-  readonly settings: JsonSettings;
-  constructor(settings: JsonSettings);
-  createSerializer(): $ShapeSerializer<Uint8Array>;
-  createDeserializer(): $ShapeDeserializer<string>;
-}
+import { $ShapeSerializer, $Codec, $ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { 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/ts3.4/submodules/protocols/json/codec-v2/JsonShapeDeserializer2.d.ts

@@ -0,0 +1,30 @@
+import { DocumentType, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { 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/ts3.4/submodules/protocols/json/codec-v2/JsonShapeSerializer2.d.ts

@@ -0,0 +1,60 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { 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/{@aws-sdk → @smithy}/core/dist-types/ts3.4/submodules/protocols/json/detectBufferParsing.d.ts

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

package/node_modules/@smithy/core/dist-types/ts3.4/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/ts3.4/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/ts3.4/submodules/protocols/json/needsReviver.d.ts

@@ -0,0 +1,11 @@
+import { 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;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/json/parseJsonBody.d.ts

@@ -0,0 +1,38 @@
+import { HttpResponse, Schema, SerdeFunctions } from "@smithy/types";
+/**
+ * @deprecated new calls to parseJsonBody must pass schema.
+ * @internal
+ */
+export declare function parseJsonBody(streamBody: any, context: SerdeFunctions): Promise<any>;
+/**
+ * @internal
+ */
+export declare function parseJsonBody(streamBody: any, context: SerdeFunctions, schema: Schema): Promise<any>;
+/**
+ * @internal
+ */
+export declare const parseJsonErrorBody: (errorBody: any, context: SerdeFunctions) => Promise<any>;
+/**
+ * @internal
+ */
+export declare const loadRestJsonErrorCode: (output: HttpResponse, data: any) => string | undefined;
+/**
+ * @internal
+ */
+export declare const loadJsonRpcErrorCode: (output: HttpResponse, data: any, queryCompat?: boolean) => string | undefined;
+/**
+ * Smithy RPCv2 JSON error identifier loader.
+ *
+ * Unlike {@link loadJsonRpcErrorCode} (used by AWS JSON 1.0/1.1 and restJson1),
+ * this preserves the ABSOLUTE shape id carried in `__type`. The RPCv2 JSON SEP
+ * requires `__type` to contain the fully-qualified shape id, and the protocol
+ * resolves errors by that absolute id to avoid ambiguous resolution when the
+ * same shape name exists in more than one namespace.
+ *
+ * It trims the Smithy-specific `,` fault/tag suffix and the `:` suffix, but does
+ * NOT strip the `#` namespace separator:
+ *   "com.a.b#Error:Sender,tag" -> "com.a.b#Error"
+ *
+ * @internal
+ */
+export declare const loadSmithyRpcV2JsonErrorCode: (output: HttpResponse, data: any) => string | undefined;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/protocol-http/extensions/httpExtensionConfiguration.d.ts

@@ -24,6 +24,7 @@ export declare const getHttpHandlerExtensionConfiguration: <HandlerConfig extend
     logger?: Logger;
 }>(runtimeConfig: HttpHandlerExtensionConfigType<HandlerConfig> & {
     logger?: Logger;
+    defaultSocketTimeout?: number;
 }) => {
     setHttpHandler(handler: HttpHandler<HandlerConfig>): void;
     httpHandler(): HttpHandler<HandlerConfig>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/service-error-classification/service-error-classification.d.ts

@@ -19,6 +19,10 @@ export declare const isThrottlingError: (error: SdkError) => boolean;
  * included here because there is an error scenario with unknown root
  * cause where the NodeHttpHandler does not decorate the Error with
  * the name "TimeoutError" to be checked by the TRANSIENT_ERROR_CODES condition.
+ *
+ * Errors named "AbortError" are considered terminal. AbortSignal.timeout()
+ * produces an underlying cause which would otherwise be considered retryable as
+ * a TimeoutError.
  */
 export declare const isTransientError: (error: SdkError, depth?: number) => boolean;
 export declare const isServerError: (error: SdkError) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/race.d.ts

@@ -0,0 +1,3 @@
+import { AbortSignal as DeprecatedAbortSignal } from "@smithy/types";
+export declare const race: <T>(promise: Promise<T>, signal?: AbortSignal | DeprecatedAbortSignal) => Promise<T>;
+export declare const isAbortError: (error: unknown) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/TypeRegistry.d.ts

@@ -10,10 +10,10 @@ export declare class TypeRegistry {
     private schemas;
     private exceptions;
     static readonly registries: Map<string, TypeRegistry>;
-    private constructor();
+    constructor(namespace: string, schemas?: Map<string, ISchema>, exceptions?: Map<StaticErrorSchema, any>);
     /**
      * @param namespace - specifier.
-     * @returns the schema for that namespace, creating it if necessary.
+     * @returns the TypeRegistry for that namespace, creating it if necessary.
      */
     static for(namespace: string): TypeRegistry;
     /**

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

@@ -40,3 +40,4 @@ export { streamCollector } from "./util-stream/stream-collector.browser";
 export declare const v4: () => string;
 export declare const generateIdempotencyToken: () => string;
 export { hasOwn } from "@smithy/core/transport";
+export { writeKey } from "./writeKey";

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

@@ -38,3 +38,4 @@ export { streamCollector } from "./util-stream/stream-collector";
 export declare const v4: () => string;
 export declare const generateIdempotencyToken: () => string;
 export { hasOwn } from "@smithy/core/transport";
+export { writeKey } from "./writeKey";

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

@@ -38,3 +38,4 @@ export { streamCollector } from "./util-stream/stream-collector.browser";
 export declare const v4: () => string;
 export declare const generateIdempotencyToken: () => string;
 export { hasOwn } from "@smithy/core/transport";
+export { writeKey } from "./writeKey";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/serde/writeKey.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Makes __proto__ writable on a given object.
+ */
+export declare function writeKey(obj: object | Record<string, unknown> | any): void;

package/node_modules/@smithy/core/errors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+export * from "./dist-types/submodules/errors/index";

package/node_modules/@smithy/core/errors.js

@@ -0,0 +1,5 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+module.exports = require("./dist-cjs/submodules/errors/index.js");

package/node_modules/@smithy/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/core",
-  "version": "3.33.3",
+  "version": "3.39.0",
   "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/main/packages/core",
   "license": "Apache-2.0",
   "author": {
@@ -24,6 +24,8 @@
     "./config.js",
     "./endpoints.d.ts",
     "./endpoints.js",
+    "./errors.d.ts",
+    "./errors.js",
     "./event-streams.d.ts",
     "./event-streams.js",
     "./protocols.d.ts",
@@ -212,11 +214,19 @@
       "node": "./dist-cjs/submodules/transport/index.js",
       "import": "./dist-es/submodules/transport/index.js",
       "require": "./dist-cjs/submodules/transport/index.js"
+    },
+    "./errors": {
+      "types": "./dist-types/submodules/errors/index.d.ts",
+      "module": "./dist-es/submodules/errors/index.js",
+      "node": "./dist-cjs/submodules/errors/index.js",
+      "import": "./dist-es/submodules/errors/index.js",
+      "require": "./dist-cjs/submodules/errors/index.js"
     }
   },
   "scripts": {
     "benchmark:cbor": "node ./scripts/cbor-perf.mjs",
     "benchmark:checksum": "node ./scripts/checksum-perf.mjs",
+    "benchmark:json": "npx tsx ./scripts/benchmark-json-serializer.ts",
     "benchmark:schema:cbor": "node ./scripts/cbor-shape-perf.mjs",
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "node ../../scripts/compilation/es_cjs.js",
@@ -232,7 +242,7 @@
     "test:integration:watch": "yarn g:vitest watch -c vitest.config.integ.mts"
   },
   "dependencies": {
-    "@smithy/types": "^4.17.2",
+    "@smithy/types": "^4.20.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/fetch-http-handler/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Change Log
 
+## 5.8.1
+
+### Patch Changes
+
+- 155aa37: Clear the `requestTimeout` timer once a request settles. The pending timer kept the request race, and the response it settled with, reachable until it fired, so every completed response (including a fully read body) was retained for the full `requestTimeout`.
+
+## 5.8.0
+
+### Minor Changes
+
+- 016389b: Allow passing custom fetch function to fetch-http-handler
+
+### Patch Changes
+
+- Updated dependencies [016389b]
+  - @smithy/types@4.18.0
+
 ## 5.7.2
 
 ### Patch Changes