@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-1

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 {};

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

@@ -0,0 +1,10 @@
+import { Uint8ArrayBlobAdapter } from "@smithy/core/serde";
+import { SerdeContext } from "@smithy/types";
+/**
+ * Collect low-level response body stream to Uint8Array.
+ *
+ * @internal
+ */
+export declare const collectBody: (streamBody: any | undefined, context: {
+    streamCollector: SerdeContext["streamCollector"];
+}) => Promise<Uint8ArrayBlobAdapter>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/extended-encode-uri-component.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Function that wraps encodeURIComponent to encode additional characters
+ * to fully adhere to RFC 3986.
+ *
+ * @internal
+ */
+export declare function extendedEncodeURIComponent(str: string): string;

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

@@ -0,0 +1,27 @@
+export { collectBody } from "./collect-stream-body";
+export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
+export { HttpBindingProtocol } from "./HttpBindingProtocol";
+export { HttpProtocol } from "./HttpProtocol";
+export { RpcProtocol } from "./RpcProtocol";
+export { RequestBuilder, requestBuilder } from "./requestBuilder";
+export { resolvedPath } from "./resolve-path";
+export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";
+export { HttpInterceptingShapeDeserializer } from "./serde/HttpInterceptingShapeDeserializer";
+export { HttpInterceptingShapeSerializer } from "./serde/HttpInterceptingShapeSerializer";
+export { ToStringShapeSerializer } from "./serde/ToStringShapeSerializer";
+export { determineTimestampFormat } from "./serde/determineTimestampFormat";
+export { SerdeContext } from "./SerdeContext";
+export { Field } from "./protocol-http/Field";
+export { Fields, FieldsOptions } from "./protocol-http/Fields";
+export { HttpHandler, HttpHandlerUserInput } from "./protocol-http/httpHandler";
+export { HttpRequest, IHttpRequest } from "@smithy/core/transport";
+export { HttpResponse } from "@smithy/core/transport";
+export { isValidHostname } from "@smithy/core/transport";
+export { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, HttpHandlerExtensionConfiguration, HttpHandlerExtensionConfigType } from "./protocol-http/extensions/httpExtensionConfiguration";
+export { FieldOptions, FieldPosition, HeaderBag, HttpMessage, HttpHandlerOptions } from "./protocol-http/types";
+export { contentLengthMiddleware, contentLengthMiddlewareOptions, getContentLengthPlugin, } from "./middleware-content-length/contentLengthMiddleware";
+export { escapeUri } from "./util-uri-escape/escape-uri";
+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";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/protocols/middleware-content-length/contentLengthMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { BodyLengthCalculator, BuildHandlerOptions, BuildMiddleware, Pluggable } from "@smithy/types";
+export declare function contentLengthMiddleware(bodyLengthChecker: BodyLengthCalculator): BuildMiddleware<any, any>;
+export declare const contentLengthMiddlewareOptions: BuildHandlerOptions;
+export declare const getContentLengthPlugin: (options: {
+    bodyLengthChecker: BodyLengthCalculator;
+}) => Pluggable<any, any>;

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

@@ -0,0 +1,49 @@
+import { FieldPosition, FieldOptions } from "@smithy/types";
+/**
+ * A name-value pair representing a single field
+ * transmitted in an HTTP Request or Response.
+ *
+ * The kind will dictate metadata placement within
+ * an HTTP message.
+ *
+ * All field names are case insensitive and
+ * case-variance must be treated as equivalent.
+ * Names MAY be normalized but SHOULD be preserved
+ * for accuracy during transmission.
+ */
+export declare class Field {
+    readonly name: string;
+    readonly kind: FieldPosition;
+    values: string[];
+    constructor({ name, kind, values }: FieldOptions);
+    /**
+     * Appends a value to the field.
+     *
+     * @param value The value to append.
+     */
+    add(value: string): void;
+    /**
+     * Overwrite existing field values.
+     *
+     * @param values The new field values.
+     */
+    set(values: string[]): void;
+    /**
+     * Remove all matching entries from list.
+     *
+     * @param value Value to remove.
+     */
+    remove(value: string): void;
+    /**
+     * Get comma-delimited string.
+     *
+     * @returns String representation of {@link Field}.
+     */
+    toString(): string;
+    /**
+     * Get string values as a list
+     *
+     * @returns Values in {@link Field} as a list.
+     */
+    get(): string[];
+}

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

@@ -0,0 +1,44 @@
+import { FieldPosition } from "@smithy/types";
+import { Field } from "./Field";
+export type FieldsOptions = {
+    fields?: Field[];
+    encoding?: string;
+};
+/**
+ * Collection of Field entries mapped by name.
+ */
+export declare class Fields {
+    private readonly entries;
+    private readonly encoding;
+    constructor({ fields, encoding }: FieldsOptions);
+    /**
+     * Set entry for a {@link Field} name. The `name`
+     * attribute will be used to key the collection.
+     *
+     * @param field The {@link Field} to set.
+     */
+    setField(field: Field): void;
+    /**
+     *  Retrieve {@link Field} entry by name.
+     *
+     * @param name The name of the {@link Field} entry
+     *  to retrieve
+     * @returns The {@link Field} if it exists.
+     */
+    getField(name: string): Field | undefined;
+    /**
+     * Delete entry from collection.
+     *
+     * @param name Name of the entry to delete.
+     */
+    removeField(name: string): void;
+    /**
+     * Helper function for retrieving specific types of fields.
+     * Used to grab all headers or all trailers.
+     *
+     * @param kind {@link FieldPosition} of entries to retrieve.
+     * @returns The {@link Field} entries with the specified
+     *  {@link FieldPosition}.
+     */
+    getByType(kind: FieldPosition): Field[];
+}

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

@@ -0,0 +1,33 @@
+import { HttpHandler } from "../httpHandler";
+/**
+ * @internal
+ */
+export interface HttpHandlerExtensionConfiguration<HandlerConfig extends object = {}> {
+    setHttpHandler(handler: HttpHandler<HandlerConfig>): void;
+    httpHandler(): HttpHandler<HandlerConfig>;
+    updateHttpClientConfig(key: keyof HandlerConfig, value: HandlerConfig[typeof key]): void;
+    httpHandlerConfigs(): HandlerConfig;
+}
+/**
+ * @internal
+ */
+export type HttpHandlerExtensionConfigType<HandlerConfig extends object = {}> = Partial<{
+    httpHandler: HttpHandler<HandlerConfig>;
+}>;
+/**
+ * Helper function to resolve default extension configuration from runtime config
+ *
+ * @internal
+ */
+export declare const getHttpHandlerExtensionConfiguration: <HandlerConfig extends object = {}>(runtimeConfig: HttpHandlerExtensionConfigType<HandlerConfig>) => {
+    setHttpHandler(handler: HttpHandler<HandlerConfig>): void;
+    httpHandler(): HttpHandler<HandlerConfig>;
+    updateHttpClientConfig(key: keyof HandlerConfig, value: HandlerConfig[typeof key]): void;
+    httpHandlerConfigs(): HandlerConfig;
+};
+/**
+ * Helper function to resolve runtime config from default extension configuration
+ *
+ * @internal
+ */
+export declare const resolveHttpHandlerRuntimeConfig: <HandlerConfig extends object = {}>(httpHandlerExtensionConfiguration: HttpHandlerExtensionConfiguration<HandlerConfig>) => HttpHandlerExtensionConfigType<HandlerConfig>;

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

@@ -0,0 +1,31 @@
+import { HttpRequest, HttpResponse } from "@smithy/core/transport";
+import { FetchHttpHandlerOptions, HttpHandlerOptions, NodeHttpHandlerOptions, RequestHandler } from "@smithy/types";
+/**
+ * @internal
+ */
+export type HttpHandler<HttpHandlerConfig extends object = {}> = RequestHandler<HttpRequest, HttpResponse, HttpHandlerOptions> & {
+    /**
+     * @internal
+     */
+    updateHttpClientConfig(key: keyof HttpHandlerConfig, value: HttpHandlerConfig[typeof key]): void;
+    /**
+     * @internal
+     */
+    httpHandlerConfigs(): HttpHandlerConfig;
+};
+/**
+ * A type representing the accepted user inputs for the `requestHandler` field
+ * of a client's constructor object.
+ * You may provide an instance of an HttpHandler, or alternatively
+ * provide the constructor arguments as an object which will be passed
+ * to the constructor of the default request handler.
+ * The default class constructor to which your arguments will be passed
+ * varies. The Node.js default is the NodeHttpHandler and the browser/react-native
+ * default is the FetchHttpHandler. In rarer cases specific clients may be
+ * configured to use other default implementations such as Websocket or HTTP2.
+ * The fallback type Record<string, unknown> is part of the union to allow
+ * passing constructor params to an unknown requestHandler type.
+ *
+ * @public
+ */
+export type HttpHandlerUserInput = HttpHandler | NodeHttpHandlerOptions | FetchHttpHandlerOptions | Record<string, unknown>;

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

@@ -0,0 +1,21 @@
+import { FieldOptions as __FieldOptions, FieldPosition as __FieldPosition, HeaderBag as __HeaderBag, HttpHandlerOptions as __HttpHandlerOptions, HttpMessage as __HttpMessage } from "@smithy/types";
+/**
+ * @deprecated Use FieldOptions from `@smithy/types` instead
+ */
+export type FieldOptions = __FieldOptions;
+/**
+ * @deprecated Use FieldPosition from `@smithy/types` instead
+ */
+export type FieldPosition = __FieldPosition;
+/**
+ * @deprecated Use HeaderBag from `@smithy/types` instead
+ */
+export type HeaderBag = __HeaderBag;
+/**
+ * @deprecated Use HttpMessage from `@smithy/types` instead
+ */
+export type HttpMessage = __HttpMessage;
+/**
+ * @deprecated Use HttpHandlerOptions from `@smithy/types` instead
+ */
+export type HttpHandlerOptions = __HttpHandlerOptions;

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

@@ -0,0 +1,5 @@
+import { QueryParameterBag } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare function buildQueryString(query: QueryParameterBag): string;

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

@@ -0,0 +1,52 @@
+import { HttpRequest } from "@smithy/core/transport";
+import { SerdeContext } from "@smithy/types";
+/**
+ * used in code-generated serde.
+ *
+ * @internal
+ */
+export declare function requestBuilder(input: any, context: SerdeContext): RequestBuilder;
+/**
+ * @internal
+ */
+export declare class RequestBuilder {
+    private input;
+    private context;
+    private query;
+    private method;
+    private headers;
+    private path;
+    private body;
+    private hostname;
+    private resolvePathStack;
+    constructor(input: any, context: SerdeContext);
+    build(): Promise<HttpRequest>;
+    /**
+     * Brevity setter for "hostname".
+     */
+    hn(hostname: string): this;
+    /**
+     * Brevity initial builder for "basepath".
+     */
+    bp(uriLabel: string): this;
+    /**
+     * Brevity incremental builder for "path".
+     */
+    p(memberName: string, labelValueProvider: () => string | undefined, uriLabel: string, isGreedyLabel: boolean): this;
+    /**
+     * Brevity setter for "headers".
+     */
+    h(headers: Record<string, string>): this;
+    /**
+     * Brevity setter for "query".
+     */
+    q(query: Record<string, string>): this;
+    /**
+     * Brevity setter for "body".
+     */
+    b(body: any): this;
+    /**
+     * Brevity setter for "method".
+     */
+    m(method: string): this;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const resolvedPath: (resolvedPath: string, input: unknown, memberName: string, labelValueProvider: () => string | undefined, uriLabel: string, isGreedyLabel: boolean) => string;