lambda-live-debugger 1.12.5 → 1.12.7

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/EventStreamSerde.d.ts

@@ -0,0 +1,80 @@
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { EventStreamMarshaller, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+/**
+ * Separated module for async mixin of EventStream serde capability.
+ * This is used by the HttpProtocol base class from \@smithy/core/protocols.
+ *
+ * @public
+ */
+export declare class EventStreamSerde {
+    private readonly marshaller;
+    private readonly serializer;
+    private readonly deserializer;
+    private readonly serdeContext?;
+    private readonly defaultContentType;
+    private readonly compositeErrorRegistry?;
+    /**
+     * Properties are injected by the HttpProtocol.
+     */
+    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, compositeErrorRegistry, }: {
+        marshaller: EventStreamMarshaller;
+        serializer: ShapeSerializer<string | Uint8Array>;
+        deserializer: ShapeDeserializer<string | Uint8Array>;
+        serdeContext?: SerdeFunctions;
+        defaultContentType: string;
+        compositeErrorRegistry?: TypeRegistry;
+    });
+    /**
+     * @param eventStream - the iterable provided by the caller.
+     * @param requestSchema - the schema of the event stream container (struct).
+     * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+     *
+     * @returns a stream suitable for the HTTP body of a request.
+     */
+    serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType, }: {
+        eventStream: AsyncIterable<any>;
+        requestSchema: NormalizedSchema;
+        initialRequest?: any;
+        /**
+         * The :event-type header value for the initial message.
+         * Defaults to "initial-request" (client→server).
+         * Server→client should pass "initial-response".
+         */
+        initialMessageType?: string;
+    }): Promise<IHttpRequest["body"] | Uint8Array>;
+    /**
+     * @param response - http response from which to read the event stream.
+     * @param unionSchema - schema of the event stream container (struct).
+     * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+     *
+     * @returns the asyncIterable of the event stream for the end-user.
+     */
+    deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType, }: {
+        response: IHttpResponse;
+        responseSchema: NormalizedSchema;
+        initialResponseContainer?: any;
+        /**
+         * The :event-type header value to match as the initial message.
+         * Defaults to "initial-response" (server→client).
+         * Server-side deserialization of client requests should pass "initial-request".
+         */
+        initialMessageType?: string;
+    }): Promise<AsyncIterable<{
+        [key: string]: any;
+        $unknown?: unknown;
+    }>>;
+    /**
+     * Reads and returns an event member. For error schemas, resolves the registered
+     * error constructor from the TypeRegistry and wraps the deserialized value
+     * so that it can be thrown as a typed exception instance by the caller.
+     */
+    private readEventMember;
+    /**
+     * @param unionMember - member name within the structure that contains an event stream union.
+     * @param unionSchema - schema of the union.
+     * @param event
+     *
+     * @returns the event body (bytes) and event type (string).
+     */
+    private writeEventBody;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/EventStreamCodec.d.ts

@@ -0,0 +1,30 @@
+import { AvailableMessage, AvailableMessages, Decoder, Encoder, Message, MessageDecoder, MessageEncoder, MessageHeaders } from "@smithy/types";
+/**
+ * A Codec that can convert binary-packed event stream messages into
+ * JavaScript objects and back again into their binary format.
+ */
+export declare class EventStreamCodec implements MessageEncoder, MessageDecoder {
+    private readonly headerMarshaller;
+    private messageBuffer;
+    private isEndOfStream;
+    constructor(toUtf8: Encoder, fromUtf8: Decoder);
+    feed(message: ArrayBufferView): void;
+    endOfStream(): void;
+    getMessage(): AvailableMessage;
+    getAvailableMessages(): AvailableMessages;
+    /**
+     * Convert a structured JavaScript object with tagged headers into a binary
+     * event stream message.
+     */
+    encode({ headers: rawHeaders, body }: Message): Uint8Array;
+    /**
+     * Convert a binary event stream message into a JavaScript object with an
+     * opaque, binary body and tagged, parsed headers.
+     */
+    decode(message: ArrayBufferView): Message;
+    /**
+     * Convert a structured JavaScript object with tagged headers into a binary
+     * event stream message header.
+     */
+    formatHeaders(rawHeaders: MessageHeaders): Uint8Array;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/HeaderMarshaller.d.ts

@@ -0,0 +1,12 @@
+import { Decoder, Encoder, MessageHeaders } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class HeaderMarshaller {
+    private readonly toUtf8;
+    private readonly fromUtf8;
+    constructor(toUtf8: Encoder, fromUtf8: Decoder);
+    format(headers: MessageHeaders): Uint8Array;
+    private formatHeaderValue;
+    parse(headers: DataView): MessageHeaders;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/Int64.d.ts

@@ -0,0 +1,20 @@
+import { Int64 as IInt64 } from "@smithy/types";
+export interface Int64 extends IInt64 {
+}
+/**
+ * A lossless representation of a signed, 64-bit integer. Instances of this
+ * class may be used in arithmetic expressions as if they were numeric
+ * primitives, but the binary representation will be preserved unchanged as the
+ * `bytes` property of the object. The bytes should be encoded as big-endian,
+ * two's complement integers.
+ */
+export declare class Int64 {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    static fromNumber(number: number): Int64;
+    /**
+     * Called implicitly by infix arithmetic operators.
+     */
+    valueOf(): number;
+    toString(): string;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/Message.d.ts

@@ -0,0 +1,26 @@
+import { Int64 } from "./Int64";
+/**
+ * An event stream message. The headers and body properties will always be
+ * defined, with empty headers represented as an object with no keys and an
+ * empty body represented as a zero-length Uint8Array.
+ */
+export interface Message {
+    headers: MessageHeaders;
+    body: Uint8Array;
+}
+export type MessageHeaders = Record<string, MessageHeaderValue>;
+type HeaderValue<K extends string, V> = {
+    type: K;
+    value: V;
+};
+export type BooleanHeaderValue = HeaderValue<"boolean", boolean>;
+export type ByteHeaderValue = HeaderValue<"byte", number>;
+export type ShortHeaderValue = HeaderValue<"short", number>;
+export type IntegerHeaderValue = HeaderValue<"integer", number>;
+export type LongHeaderValue = HeaderValue<"long", Int64>;
+export type BinaryHeaderValue = HeaderValue<"binary", Uint8Array>;
+export type StringHeaderValue = HeaderValue<"string", string>;
+export type TimestampHeaderValue = HeaderValue<"timestamp", Date>;
+export type UuidHeaderValue = HeaderValue<"uuid", string>;
+export type MessageHeaderValue = BooleanHeaderValue | ByteHeaderValue | ShortHeaderValue | IntegerHeaderValue | LongHeaderValue | BinaryHeaderValue | StringHeaderValue | TimestampHeaderValue | UuidHeaderValue;
+export {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/MessageDecoderStream.d.ts

@@ -0,0 +1,17 @@
+import { Message, MessageDecoder } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface MessageDecoderStreamOptions {
+    inputStream: AsyncIterable<Uint8Array>;
+    decoder: MessageDecoder;
+}
+/**
+ * @internal
+ */
+export declare class MessageDecoderStream implements AsyncIterable<Message> {
+    private readonly options;
+    constructor(options: MessageDecoderStreamOptions);
+    [Symbol.asyncIterator](): AsyncIterator<Message>;
+    private asyncIterator;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/MessageEncoderStream.d.ts

@@ -0,0 +1,18 @@
+import { Message, MessageEncoder } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface MessageEncoderStreamOptions {
+    messageStream: AsyncIterable<Message>;
+    encoder: MessageEncoder;
+    includeEndFrame?: boolean;
+}
+/**
+ * @internal
+ */
+export declare class MessageEncoderStream implements AsyncIterable<Uint8Array> {
+    private readonly options;
+    constructor(options: MessageEncoderStreamOptions);
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+    private asyncIterator;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/SmithyMessageDecoderStream.d.ts

@@ -0,0 +1,17 @@
+import { Message } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface SmithyMessageDecoderStreamOptions<T> {
+    readonly messageStream: AsyncIterable<Message>;
+    readonly deserializer: (input: Message) => Promise<T | undefined>;
+}
+/**
+ * @internal
+ */
+export declare class SmithyMessageDecoderStream<T> implements AsyncIterable<T> {
+    private readonly options;
+    constructor(options: SmithyMessageDecoderStreamOptions<T>);
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    private asyncIterator;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/SmithyMessageEncoderStream.d.ts

@@ -0,0 +1,17 @@
+import { Message } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface SmithyMessageEncoderStreamOptions<T> {
+    inputStream: AsyncIterable<T>;
+    serializer: (event: T) => Message;
+}
+/**
+ * @internal
+ */
+export declare class SmithyMessageEncoderStream<T> implements AsyncIterable<Message> {
+    private readonly options;
+    constructor(options: SmithyMessageEncoderStreamOptions<T>);
+    [Symbol.asyncIterator](): AsyncIterator<Message>;
+    private asyncIterator;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-codec/splitMessage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+export interface MessageParts {
+    headers: DataView;
+    body: Uint8Array;
+}
+/**
+ * @internal
+ */
+export declare function splitMessage({ byteLength, byteOffset, buffer }: ArrayBufferView): MessageParts;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde/EventStreamMarshaller.browser.d.ts

@@ -0,0 +1,46 @@
+import { Decoder, Encoder, EventStreamSerdeProvider, EventStreamMarshaller as IEventStreamMarshaller, Message } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface EventStreamMarshallerOptions {
+    utf8Encoder: Encoder;
+    utf8Decoder: Decoder;
+}
+/**
+ * Utility class used to serialize and deserialize event streams in
+ * browsers and ReactNative.
+ *
+ * In browsers where ReadableStream API is available:
+ * * deserialize from ReadableStream to an async iterable of output structure
+ * * serialize from async iterable of input structure to ReadableStream
+ * In ReactNative where only async iterable API is available:
+ * * deserialize from async iterable of binaries to async iterable of output structure
+ * * serialize from async iterable of input structure to async iterable of binaries
+ *
+ * We use ReadableStream API in browsers because of the consistency with other
+ * streaming operations, where ReadableStream API is used to denote streaming data.
+ * Whereas in ReactNative, ReadableStream API is not available, we use async iterable
+ * for streaming data, although it has lower throughput.
+ *
+ * @internal
+ */
+export declare class EventStreamMarshaller implements IEventStreamMarshaller {
+    private readonly universalMarshaller;
+    constructor({ utf8Encoder, utf8Decoder }: EventStreamMarshallerOptions);
+    deserialize<T>(body: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+    /**
+     * Generate a stream that serialize events into stream of binary chunks;
+     *
+     * Caveat is that streaming request payload doesn't work on browser with native
+     * xhr or fetch handler currently because they don't support upload streaming.
+     * reference:
+     * * https://bugs.chromium.org/p/chromium/issues/detail?id=688906
+     * * https://bugzilla.mozilla.org/show_bug.cgi?id=1387483
+     *
+     */
+    serialize<T>(input: AsyncIterable<T>, serializer: (event: T) => Message): ReadableStream | AsyncIterable<Uint8Array>;
+}
+/**
+ * @internal
+ */
+export declare const eventStreamSerdeProvider: EventStreamSerdeProvider;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde/EventStreamMarshaller.d.ts

@@ -0,0 +1,31 @@
+import { Readable } from "node:stream";
+import { Decoder, Encoder, EventStreamSerdeProvider, EventStreamMarshaller as IEventStreamMarshaller, Message } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface EventStreamMarshallerOptions {
+    utf8Encoder: Encoder;
+    utf8Decoder: Decoder;
+}
+/**
+ * @internal
+ */
+export declare class EventStreamMarshaller implements IEventStreamMarshaller {
+    private readonly universalMarshaller;
+    constructor({ utf8Encoder, utf8Decoder }: EventStreamMarshallerOptions);
+    deserialize<T>(body: Readable, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+    serialize<T>(input: AsyncIterable<T>, serializer: (event: T) => Message): Readable;
+}
+/**
+ * @internal
+ */
+export declare const eventStreamSerdeProvider: EventStreamSerdeProvider;
+/**
+ * Convert object stream piped in into an async iterable. This
+ * adaptor should be deprecated when Node stream iterator is stable.
+ * Caveat: this adaptor won't have backpressure to inwards stream
+ *
+ * Reference: https://nodejs.org/docs/latest-v11.x/api/stream.html#stream_readable_symbol_asynciterator
+ * @internal
+ */
+export declare function readableToIterable<T>(readStream: Readable): AsyncIterable<T>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A util function converting ReadableStream into an async iterable.
+ * Reference: https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate
+ * @internal
+ */
+export declare const readableStreamToIterable: <T>(readableStream: ReadableStream<T>) => AsyncIterable<T>;
+/**
+ * A util function converting async iterable to a ReadableStream.
+ * @internal
+ */
+export declare const iterableToReadableStream: <T>(asyncIterable: AsyncIterable<T>) => ReadableStream<T>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde-config-resolver/EventStreamSerdeConfig.d.ts

@@ -0,0 +1,27 @@
+import { EventStreamMarshaller, EventStreamSerdeProvider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface EventStreamSerdeInputConfig {
+}
+/**
+ * @internal
+ */
+export interface EventStreamSerdeResolvedConfig {
+    eventStreamMarshaller: EventStreamMarshaller;
+}
+/**
+ * @internal
+ */
+interface PreviouslyResolved {
+    /**
+     * Provide the event stream marshaller for the given runtime
+     * @internal
+     */
+    eventStreamSerdeProvider: EventStreamSerdeProvider;
+}
+/**
+ * @internal
+ */
+export declare const resolveEventStreamSerdeConfig: <T>(input: T & PreviouslyResolved & EventStreamSerdeInputConfig) => T & EventStreamSerdeResolvedConfig;
+export {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.d.ts

@@ -0,0 +1,22 @@
+import { Decoder, Encoder, EventStreamSerdeProvider, EventStreamMarshaller as IEventStreamMarshaller, Message } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface EventStreamMarshallerOptions {
+    utf8Encoder: Encoder;
+    utf8Decoder: Decoder;
+}
+/**
+ * @internal
+ */
+export declare class EventStreamMarshaller implements IEventStreamMarshaller {
+    private readonly eventStreamCodec;
+    private readonly utfEncoder;
+    constructor({ utf8Encoder, utf8Decoder }: EventStreamMarshallerOptions);
+    deserialize<T>(body: AsyncIterable<Uint8Array>, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+    serialize<T>(inputStream: AsyncIterable<T>, serializer: (event: T) => Message): AsyncIterable<Uint8Array>;
+}
+/**
+ * @internal
+ */
+export declare const eventStreamSerdeProvider: EventStreamSerdeProvider;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde-universal/getChunkedStream.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare function getChunkedStream(source: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/event-streams/eventstream-serde-universal/getUnmarshalledStream.d.ts

@@ -0,0 +1,18 @@
+import { Encoder, Message } from "@smithy/types";
+import { EventStreamCodec } from "../eventstream-codec/EventStreamCodec";
+/**
+ * @internal
+ */
+export type UnmarshalledStreamOptions<T> = {
+    eventStreamCodec: EventStreamCodec;
+    deserializer: (input: Record<string, Message>) => Promise<T>;
+    toUtf8: Encoder;
+};
+/**
+ * @internal
+ */
+export declare function getUnmarshalledStream<T extends Record<string, any>>(source: AsyncIterable<Uint8Array>, options: UnmarshalledStreamOptions<T>): AsyncIterable<T>;
+/**
+ * @internal
+ */
+export declare function getMessageUnmarshaller<T extends Record<string, any>>(deserializer: (input: Record<string, Message>) => Promise<T>, toUtf8: Encoder): (input: Message) => Promise<T | undefined>;

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

@@ -0,0 +1,23 @@
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export { Message, MessageHeaders, MessageHeaderValue, BooleanHeaderValue, ByteHeaderValue, ShortHeaderValue, IntegerHeaderValue, LongHeaderValue, BinaryHeaderValue, StringHeaderValue, TimestampHeaderValue, UuidHeaderValue, } from "./eventstream-codec/Message";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export { MessageDecoderStreamOptions } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export { MessageEncoderStreamOptions } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageDecoderStreamOptions } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { SmithyMessageEncoderStreamOptions } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller.browser";
+export { EventStreamMarshallerOptions } from "./eventstream-serde/EventStreamMarshaller.browser";
+export { readableStreamToIterable, iterableToReadableStream } from "./eventstream-serde/utils";
+export { EventStreamMarshaller as UniversalEventStreamMarshaller, eventStreamSerdeProvider as universalEventStreamSerdeProvider, } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { EventStreamMarshallerOptions as UniversalEventStreamMarshallerOptions } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { UnmarshalledStreamOptions } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerdeInputConfig, EventStreamSerdeResolvedConfig, } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

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

@@ -0,0 +1,23 @@
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export { Message, MessageHeaders, MessageHeaderValue, BooleanHeaderValue, ByteHeaderValue, ShortHeaderValue, IntegerHeaderValue, LongHeaderValue, BinaryHeaderValue, StringHeaderValue, TimestampHeaderValue, UuidHeaderValue, } from "./eventstream-codec/Message";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export { MessageDecoderStreamOptions } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export { MessageEncoderStreamOptions } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageDecoderStreamOptions } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { SmithyMessageEncoderStreamOptions } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller";
+export { EventStreamMarshallerOptions } from "./eventstream-serde/EventStreamMarshaller";
+export { readableStreamToIterable, iterableToReadableStream } from "./eventstream-serde/utils";
+export { EventStreamMarshaller as UniversalEventStreamMarshaller, eventStreamSerdeProvider as universalEventStreamSerdeProvider, } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { EventStreamMarshallerOptions as UniversalEventStreamMarshallerOptions } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { UnmarshalledStreamOptions } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerdeInputConfig, EventStreamSerdeResolvedConfig, } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

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

@@ -0,0 +1,31 @@
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { HttpRequest } from "@smithy/core/transport";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, Schema, SerdeFunctions } from "@smithy/types";
+import { HttpProtocol } from "./HttpProtocol";
+/**
+ * Base for HTTP-binding protocols. Downstream examples
+ * include AWS REST JSON and AWS REST XML.
+ *
+ * @public
+ */
+export declare abstract class HttpBindingProtocol extends HttpProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, _input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    protected serializeQuery(ns: NormalizedSchema, data: any, query: HttpRequest["query"]): void;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    /**
+     * The base method ignores HTTP bindings.
+     *
+     * @deprecated (only this signature) use signature without headerBindings.
+     * @override
+     */
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[] & {
+        discardResponseBody?: boolean;
+    }>;
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any): Promise<string[] & {
+        discardResponseBody?: boolean;
+    }>;
+}

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

@@ -0,0 +1,95 @@
+import { EventStreamSerde } from "@smithy/core/event-streams";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, EventStreamMarshaller, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import { SerdeContext } from "./SerdeContext";
+/**
+ * Abstract base for HTTP-based client protocols.
+ *
+ * @public
+ */
+export declare abstract class HttpProtocol extends SerdeContext implements ClientProtocol<IHttpRequest, IHttpResponse> {
+    readonly options: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    };
+    /**
+     * An error registry having the namespace of the modeled service,
+     * but combining all error schemas found within the service closure.
+     *
+     * Used to look up error schema during deserialization.
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    protected abstract serializer: ShapeSerializer<string | Uint8Array>;
+    protected abstract deserializer: ShapeDeserializer<string | Uint8Array>;
+    /**
+     * @param options.defaultNamespace - used by various implementing classes.
+     * @param options.errorTypeRegistries - registry instances that contribute to error deserialization.
+     */
+    protected constructor(options: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    abstract getShapeId(): string;
+    abstract getPayloadCodec(): Codec<any, any>;
+    getRequestType(): new (...args: any[]) => IHttpRequest;
+    getResponseType(): new (...args: any[]) => IHttpResponse;
+    /**
+     * @override
+     */
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    abstract serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    updateServiceEndpoint(request: IHttpRequest, endpoint: EndpointV2 | Endpoint): IHttpRequest;
+    abstract deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected setHostPrefix<Input extends object>(request: IHttpRequest, operationSchema: OperationSchema, input: Input): void;
+    protected abstract handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected deserializeMetadata(output: IHttpResponse): ResponseMetadata;
+    /**
+     * @param eventStream - the iterable provided by the caller.
+     * @param requestSchema - the schema of the event stream container (struct).
+     * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+     *
+     * @returns a stream suitable for the HTTP body of a request.
+     */
+    protected serializeEventStream({ eventStream, requestSchema, initialRequest, }: {
+        eventStream: AsyncIterable<any>;
+        requestSchema: NormalizedSchema;
+        initialRequest?: any;
+    }): Promise<IHttpRequest["body"]>;
+    /**
+     * @param response - http response from which to read the event stream.
+     * @param unionSchema - schema of the event stream container (struct).
+     * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+     *
+     * @returns the asyncIterable of the event stream.
+     */
+    protected deserializeEventStream({ response, responseSchema, initialResponseContainer, }: {
+        response: IHttpResponse;
+        responseSchema: NormalizedSchema;
+        initialResponseContainer?: any;
+    }): Promise<AsyncIterable<{
+        [key: string]: any;
+        $unknown?: unknown;
+    }>>;
+    /**
+     * Loads eventStream capability async (for chunking).
+     */
+    protected loadEventStreamCapability(): Promise<EventStreamSerde>;
+    /**
+     * Returns a platform-specific EventStreamMarshaller.
+     * Prefers user-injected marshaller from serdeContext (via client config),
+     * falls back to the dynamically imported provider.
+     */
+    private resolveEventStreamMarshaller;
+    /**
+     * @returns content-type default header value for event stream events and other documents.
+     */
+    protected getDefaultContentType(): string;
+    /**
+     * For HTTP binding protocols, this method is overridden in {@link HttpBindingProtocol}.
+     *
+     * @deprecated only use this for HTTP binding protocols.
+     */
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
+    protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any): Promise<string[]>;
+    protected getEventStreamMarshaller(): EventStreamMarshaller;
+}

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

@@ -0,0 +1,16 @@
+import { TypeRegistry } from "@smithy/core/schema";
+import { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, SerdeFunctions } from "@smithy/types";
+import { HttpProtocol } from "./HttpProtocol";
+/**
+ * Abstract base for RPC-over-HTTP protocols.
+ *
+ * @public
+ */
+export declare abstract class RpcProtocol extends HttpProtocol {
+    /**
+     * @override
+     */
+    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>;
+}

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

@@ -0,0 +1,16 @@
+import { ConfigurableSerdeContext, SerdeFunctions } from "@smithy/types";
+/**
+ * This in practice should be the client config object.
+ * @internal
+ */
+type SerdeContextType = SerdeFunctions & {
+    disableHostPrefix?: boolean;
+};
+/**
+ * @internal
+ */
+export declare abstract class SerdeContext implements ConfigurableSerdeContext {
+    protected serdeContext?: SerdeContextType;
+    setSerdeContext(serdeContext: SerdeContextType): void;
+}
+export {};