@psnext/slingcli 2.4.20260509-2 → 2.4.20260515-1

package/node_modules/@smithy/core/dist-types/submodules/endpoints/middleware-endpoint/adaptors/getEndpointFromInstructions.d.ts

@@ -0,0 +1,21 @@
+import type { EndpointParameters, EndpointV2, HandlerExecutionContext } from "@smithy/types";
+import type { EndpointResolvedConfig } from "../resolveEndpointConfig";
+import type { EndpointParameterInstructions } from "../types";
+/**
+ * @internal
+ */
+export type EndpointParameterInstructionsSupplier = Partial<{
+    getEndpointParameterInstructions(): EndpointParameterInstructions;
+}>;
+/**
+ * @internal
+ */
+export type GetEndpointFromConfig = (serviceId?: string) => Promise<string | undefined>;
+/**
+ * @internal
+ */
+export declare function bindGetEndpointFromInstructions(getEndpointFromConfig: GetEndpointFromConfig): <T extends EndpointParameters, CommandInput extends Record<string, unknown>, Config extends Record<string, unknown>>(commandInput: CommandInput, instructionsSupplier: EndpointParameterInstructionsSupplier, clientConfig: Partial<EndpointResolvedConfig<T>> & Config, context?: HandlerExecutionContext) => Promise<EndpointV2>;
+/**
+ * @internal
+ */
+export declare const resolveParams: <T extends EndpointParameters, CommandInput extends Record<string, unknown>, Config extends Record<string, unknown>>(commandInput: CommandInput, instructionsSupplier: EndpointParameterInstructionsSupplier, clientConfig: Partial<EndpointResolvedConfig<T>> & Config) => Promise<EndpointParameters>;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/middleware-endpoint/adaptors/getEndpointUrlConfig.d.ts

@@ -0,0 +1,2 @@
+import { type LoadedConfigSelectors } from "@smithy/core/config";
+export declare const getEndpointUrlConfig: (serviceId: string) => LoadedConfigSelectors<string | undefined>;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/middleware-endpoint/adaptors/toEndpointV1.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use `toEndpointV1` from `@smithy/core/endpoints` instead.
+ * @internal
+ */
+export { toEndpointV1 } from "../../toEndpointV1";

package/node_modules/@smithy/core/dist-types/submodules/endpoints/middleware-endpoint/endpointMiddleware.d.ts

@@ -0,0 +1,11 @@
+import type { EndpointParameters, SerializeMiddleware } from "@smithy/types";
+import { type GetEndpointFromConfig } from "./adaptors/getEndpointFromInstructions";
+import type { EndpointResolvedConfig } from "./resolveEndpointConfig";
+import type { EndpointParameterInstructions } from "./types";
+/**
+ * @internal
+ */
+export declare function bindEndpointMiddleware(getEndpointFromConfig: GetEndpointFromConfig): <T extends EndpointParameters>({ config, instructions, }: {
+    config: EndpointResolvedConfig<T>;
+    instructions: EndpointParameterInstructions;
+}) => SerializeMiddleware<any, any>;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/middleware-endpoint/getEndpointPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { EndpointParameters, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import type { GetEndpointFromConfig } from "./adaptors/getEndpointFromInstructions";
+import type { EndpointResolvedConfig } from "./resolveEndpointConfig";
+import type { EndpointParameterInstructions } from "./types";
+/**
+ * @internal
+ */
+export declare const endpointMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+export declare function bindGetEndpointPlugin(getEndpointFromConfig: GetEndpointFromConfig): <T extends EndpointParameters>(config: EndpointResolvedConfig<T>, instructions: EndpointParameterInstructions) => Pluggable<any, any>;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/middleware-endpoint/resolveEndpointConfig.d.ts

@@ -0,0 +1,110 @@
+import type { Endpoint, EndpointParameters, EndpointV2, Logger, Provider, UrlParser } from "@smithy/types";
+import type { GetEndpointFromConfig } from "./adaptors/getEndpointFromInstructions";
+/**
+ * Endpoint config interfaces and resolver for Endpoint v2. They live in separate package to allow per-service onboarding.
+ * When all services onboard Endpoint v2, the resolver in config-resolver package can be removed.
+ * This interface includes all the endpoint parameters with built-in bindings of "AWS::*" and "SDK::*"
+ *
+ * @public
+ */
+export interface EndpointInputConfig<T extends EndpointParameters = EndpointParameters> {
+    /**
+     * The fully qualified endpoint of the webservice. This is only for using
+     * a custom endpoint (for example, when using a local version of S3).
+     *
+     * Endpoint transformations such as S3 applying a bucket to the hostname are
+     * still applicable to this custom endpoint.
+     */
+    endpoint?: string | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+    /**
+     * Providing a custom endpointProvider will override
+     * built-in transformations of the endpoint such as S3 adding the bucket
+     * name to the hostname, since they are part of the default endpointProvider.
+     */
+    endpointProvider?: (params: T, context?: {
+        logger?: Logger;
+    }) => EndpointV2;
+    /**
+     * Whether TLS is enabled for requests.
+     * @deprecated
+     */
+    tls?: boolean;
+    /**
+     * Enables IPv6/IPv4 dualstack endpoint.
+     */
+    useDualstackEndpoint?: boolean | Provider<boolean | undefined>;
+    /**
+     * Enables FIPS compatible endpoints.
+     */
+    useFipsEndpoint?: boolean | Provider<boolean | undefined>;
+    /**
+     * This field is used internally so you should not fill any value to this field.
+     *
+     * @internal
+     */
+    serviceConfiguredEndpoint?: never;
+}
+/**
+ * @internal
+ */
+export interface PreviouslyResolved<T extends EndpointParameters = EndpointParameters> {
+    urlParser: UrlParser;
+    endpointProvider: (params: T, context?: {
+        logger?: Logger;
+    }) => EndpointV2;
+    logger?: Logger;
+    serviceId?: string;
+}
+/**
+ * This supersedes the similarly named EndpointsResolvedConfig (no parametric types)
+ * from resolveEndpointsConfig.ts in \@smithy/config-resolver.
+ *
+ * @internal
+ */
+export interface EndpointResolvedConfig<T extends EndpointParameters = EndpointParameters> {
+    /**
+     * Custom endpoint provided by the user.
+     * This is normalized to a single interface from the various acceptable types.
+     * This field will be undefined if a custom endpoint is not provided.
+     */
+    endpoint?: Provider<Endpoint>;
+    endpointProvider: (params: T, context?: {
+        logger?: Logger;
+    }) => EndpointV2;
+    /**
+     * Whether TLS is enabled for requests.
+     * @deprecated
+     */
+    tls: boolean;
+    /**
+     * Whether the endpoint is specified by caller.
+     * This should be used over checking the existence of `endpoint`, since
+     * that may have been set by other means, such as the default regional
+     * endpoint provider function.
+     *
+     * @internal
+     */
+    isCustomEndpoint?: boolean;
+    /**
+     * Resolved value for input {@link EndpointsInputConfig.useDualstackEndpoint}
+     */
+    useDualstackEndpoint: Provider<boolean>;
+    /**
+     * Resolved value for input {@link EndpointsInputConfig.useFipsEndpoint}
+     */
+    useFipsEndpoint: Provider<boolean>;
+    /**
+     * Unique service identifier.
+     * @internal
+     */
+    serviceId?: string;
+    /**
+     * A configured endpoint global or specific to the service from ENV or AWS SDK configuration files.
+     * @internal
+     */
+    serviceConfiguredEndpoint?: Provider<string | undefined>;
+}
+/**
+ * @internal
+ */
+export declare function bindResolveEndpointConfig(getEndpointFromConfig: GetEndpointFromConfig): <T, P extends EndpointParameters = EndpointParameters>(input: T & EndpointInputConfig<P> & PreviouslyResolved<P>) => T & EndpointResolvedConfig<P>;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/cache/EndpointCache.d.ts

@@ -0,0 +1,34 @@
+import type { EndpointParams, EndpointV2 } from "@smithy/types";
+/**
+ * Cache for endpoint ruleSet resolution.
+ *
+ * @internal
+ */
+export declare class EndpointCache {
+    private capacity;
+    private data;
+    private parameters;
+    /**
+     * @param [size] - desired average maximum capacity. A buffer of 10 additional keys will be allowed
+     *                 before keys are dropped.
+     * @param [params] - list of params to consider as part of the cache key.
+     *
+     * If the params list is not populated, no caching will happen.
+     * This may be out of order depending on how the object is created and arrives to this class.
+     */
+    constructor({ size, params }: {
+        size?: number;
+        params?: string[];
+    });
+    /**
+     * @param endpointParams - query for endpoint.
+     * @param resolver - provider of the value if not present.
+     * @returns endpoint corresponding to the query.
+     */
+    get(endpointParams: EndpointParams, resolver: () => EndpointV2): EndpointV2;
+    size(): number;
+    /**
+     * @returns cache key or false if not cachable.
+     */
+    private hash;
+}

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/decideEndpoint.d.ts

@@ -0,0 +1,7 @@
+import type { EndpointV2 } from "@smithy/types";
+import type { BinaryDecisionDiagram } from "./bdd/BinaryDecisionDiagram";
+import { type EndpointResolverOptions } from "./types";
+/**
+ * Resolves an endpoint URL by processing the endpoints bdd and options.
+ */
+export declare const decideEndpoint: (bdd: BinaryDecisionDiagram, options: EndpointResolverOptions) => EndpointV2;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/getEndpointUrlConfig.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Inlined from @smithy/core/config to avoid circular dependency.
+ *
+ * @internal
+ */
+type LoadedConfigSelectors<T> = {
+    environmentVariableSelector: (env: Record<string, string | undefined>) => T | undefined;
+    configFileSelector: (profile: Record<string, string | undefined>, configFile?: Record<string, Record<string, string | undefined>>) => T | undefined;
+    default: T | (() => T);
+};
+export declare const getEndpointUrlConfig: (serviceId: string) => LoadedConfigSelectors<string | undefined>;
+export {};

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/lib/parseURL.d.ts

@@ -0,0 +1,5 @@
+import { type Endpoint, type EndpointURL } from "@smithy/types";
+/**
+ * Parses a string, URL, or Endpoint into it’s Endpoint URL components.
+ */
+export declare const parseURL: (value: string | URL | Endpoint) => EndpointURL | null;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/resolveEndpoint.d.ts

@@ -0,0 +1,6 @@
+import type { EndpointV2 } from "@smithy/types";
+import { type EndpointResolverOptions, type RuleSetObject } from "./types";
+/**
+ * Resolves an endpoint URL by processing the endpoints ruleset and options.
+ */
+export declare const resolveEndpoint: (ruleSetObject: RuleSetObject, options: EndpointResolverOptions) => EndpointV2;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateCondition.d.ts

@@ -0,0 +1,11 @@
+import { type ConditionObject, type EvaluateOptions } from "../types";
+export declare const evaluateCondition: (condition: ConditionObject, options: EvaluateOptions) => {
+    result: boolean;
+    toAssign: {
+        name: string;
+        value: import("../types").FunctionReturn;
+    };
+} | {
+    result: boolean;
+    toAssign?: undefined;
+};

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateErrorRule.d.ts

@@ -0,0 +1,2 @@
+import { type ErrorRuleObject, type EvaluateOptions } from "../types";
+export declare const evaluateErrorRule: (errorRule: ErrorRuleObject, options: EvaluateOptions) => void;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateExpression.d.ts

@@ -0,0 +1,7 @@
+import { type EvaluateOptions, type Expression, type FunctionObject, type FunctionReturn } from "../types";
+export declare const evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => FunctionReturn;
+export declare const callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
+export declare const group: {
+    evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => FunctionReturn;
+    callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
+};

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/evaluateRules.d.ts

@@ -0,0 +1,8 @@
+import type { EndpointV2 } from "@smithy/types";
+import { type EvaluateOptions, type RuleSetRules, type TreeRuleObject } from "../types";
+export declare const evaluateRules: (rules: RuleSetRules, options: EvaluateOptions) => EndpointV2;
+export declare const evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
+export declare const group: {
+    evaluateRules: (rules: RuleSetRules, options: EvaluateOptions) => EndpointV2;
+    evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
+};

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/getEndpointHeaders.d.ts

@@ -0,0 +1,2 @@
+import { type EndpointObjectHeaders, type EvaluateOptions } from "../types";
+export declare const getEndpointHeaders: (headers: EndpointObjectHeaders, options: EvaluateOptions) => Record<string, string[]>;

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/getEndpointProperties.d.ts

@@ -0,0 +1,8 @@
+import type { EndpointObjectProperty } from "@smithy/types";
+import { type EndpointObjectProperties, type EvaluateOptions } from "../types";
+export declare const getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => Record<string, EndpointObjectProperty>;
+export declare const getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
+export declare const group: {
+    getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
+    getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => Record<string, EndpointObjectProperty>;
+};

package/node_modules/@smithy/core/dist-types/submodules/endpoints/util-endpoints/utils/getEndpointUrl.d.ts

@@ -0,0 +1,2 @@
+import { type EvaluateOptions, type Expression } from "../types";
+export declare const getEndpointUrl: (endpointUrl: Expression, options: EvaluateOptions) => URL;

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

@@ -0,0 +1,30 @@
+import type { 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/submodules/event-streams/eventstream-serde/EventStreamMarshaller.browser.d.ts

@@ -0,0 +1,46 @@
+import type { 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/submodules/event-streams/eventstream-serde/EventStreamMarshaller.d.ts

@@ -0,0 +1,31 @@
+import { Readable } from "node:stream";
+import type { 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/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/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.d.ts

@@ -0,0 +1,22 @@
+import type { 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/submodules/event-streams/eventstream-serde-universal/getUnmarshalledStream.d.ts

@@ -0,0 +1,18 @@
+import type { Encoder, Message } from "@smithy/types";
+import type { 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/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 type { Message, MessageHeaders, MessageHeaderValue, BooleanHeaderValue, ByteHeaderValue, ShortHeaderValue, IntegerHeaderValue, LongHeaderValue, BinaryHeaderValue, StringHeaderValue, TimestampHeaderValue, UuidHeaderValue, } from "./eventstream-codec/Message";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export type { MessageDecoderStreamOptions } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export type { MessageEncoderStreamOptions } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export type { SmithyMessageDecoderStreamOptions } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export type { SmithyMessageEncoderStreamOptions } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller.browser";
+export type { 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 type { EventStreamMarshallerOptions as UniversalEventStreamMarshallerOptions } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export type { UnmarshalledStreamOptions } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export type { EventStreamSerdeInputConfig, EventStreamSerdeResolvedConfig, } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

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

@@ -1 +1,23 @@
-export * from "./EventStreamSerde";
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export type { Message, MessageHeaders, MessageHeaderValue, BooleanHeaderValue, ByteHeaderValue, ShortHeaderValue, IntegerHeaderValue, LongHeaderValue, BinaryHeaderValue, StringHeaderValue, TimestampHeaderValue, UuidHeaderValue, } from "./eventstream-codec/Message";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export type { MessageDecoderStreamOptions } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export type { MessageEncoderStreamOptions } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export type { SmithyMessageDecoderStreamOptions } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export type { SmithyMessageEncoderStreamOptions } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller";
+export type { 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 type { EventStreamMarshallerOptions as UniversalEventStreamMarshallerOptions } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export type { UnmarshalledStreamOptions } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export type { EventStreamSerdeInputConfig, EventStreamSerdeResolvedConfig, } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

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

@@ -1,7 +1,7 @@
-import { type TypeRegistry, NormalizedSchema } from "@smithy/core/schema";
-import { HttpRequest } from "@smithy/protocol-http";
+import { NormalizedSchema, type TypeRegistry } from "@smithy/core/schema";
 import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, Schema, SerdeFunctions } from "@smithy/types";
 import { HttpProtocol } from "./HttpProtocol";
+import { HttpRequest } from "./protocol-http/httpRequest";
 /**
  * Base for HTTP-binding protocols. Downstream examples
  * include AWS REST JSON and AWS REST XML.

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

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

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

@@ -1,7 +1,7 @@
 /**
- * @internal
- *
  * 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/submodules/protocols/index.d.ts

@@ -11,3 +11,17 @@ export * from "./serde/HttpInterceptingShapeSerializer";
 export * from "./serde/ToStringShapeSerializer";
 export * from "./serde/determineTimestampFormat";
 export * from "./SerdeContext";
+export { Field } from "./protocol-http/Field";
+export { Fields, type FieldsOptions } from "./protocol-http/Fields";
+export { type HttpHandler, type HttpHandlerUserInput } from "./protocol-http/httpHandler";
+export { HttpRequest, type IHttpRequest } from "./protocol-http/httpRequest";
+export { HttpResponse } from "./protocol-http/httpResponse";
+export { isValidHostname } from "./protocol-http/isValidHostname";
+export { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, type HttpHandlerExtensionConfiguration, type HttpHandlerExtensionConfigType, } from "./protocol-http/extensions/httpExtensionConfiguration";
+export { type FieldOptions, type FieldPosition, type HeaderBag, type HttpMessage, type 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 "./querystring-parser/parseQueryString";
+export { parseUrl } from "./url-parser/parseUrl";

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

@@ -0,0 +1,49 @@
+import { FieldPosition, type 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[];
+}