@cdk8s/awscdk-resolver 0.0.562 → 0.0.564

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-config-resolver/EventStreamSerdeConfig.d.ts

@@ -0,0 +1,27 @@
+import type { 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/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/getChunkedStream.d.ts

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

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/middleware-content-length/contentLengthMiddleware.d.ts

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

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

@@ -0,0 +1,33 @@
+import type { 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/submodules/protocols/protocol-http/httpHandler.d.ts

@@ -0,0 +1,32 @@
+import type { FetchHttpHandlerOptions, HttpHandlerOptions, NodeHttpHandlerOptions, RequestHandler } from "@smithy/types";
+import type { HttpRequest } from "./httpRequest";
+import type { HttpResponse } from "./httpResponse";
+/**
+ * @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/submodules/protocols/protocol-http/httpRequest.d.ts

@@ -0,0 +1,55 @@
+import { HttpRequest as IHttpRequest, type HeaderBag, type HttpMessage, type QueryParameterBag, type URI } from "@smithy/types";
+type HttpRequestOptions = Partial<HttpMessage> & Partial<URI> & {
+    method?: string;
+};
+/**
+ * Use the distinct IHttpRequest interface from \@smithy/types instead.
+ * This should not be used due to
+ * overlapping with the concrete class' name.
+ *
+ * This is not marked deprecated since that would mark the concrete class
+ * deprecated as well.
+ *
+ * @internal
+ */
+export interface HttpRequest extends IHttpRequest {
+}
+/**
+ * @public
+ */
+export { IHttpRequest };
+/**
+ * @public
+ */
+export declare class HttpRequest implements HttpMessage, URI {
+    method: string;
+    protocol: string;
+    hostname: string;
+    port?: number;
+    path: string;
+    query: QueryParameterBag;
+    headers: HeaderBag;
+    username?: string;
+    password?: string;
+    fragment?: string;
+    body?: any;
+    constructor(options: HttpRequestOptions);
+    /**
+     * Note: this does not deep-clone the body.
+     */
+    static clone(request: IHttpRequest): HttpRequest;
+    /**
+     * This method only actually asserts that request is the interface {@link IHttpRequest},
+     * and not necessarily this concrete class. Left in place for API stability.
+     *
+     * Do not call instance methods on the input of this function, and
+     * do not assume it has the HttpRequest prototype.
+     */
+    static isInstance(request: unknown): request is HttpRequest;
+    /**
+     * @deprecated use static HttpRequest.clone(request) instead. It's not safe to call
+     * this method because {@link HttpRequest.isInstance} incorrectly
+     * asserts that IHttpRequest (interface) objects are of type HttpRequest (class).
+     */
+    clone(): HttpRequest;
+}

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

@@ -1,8 +1,9 @@
-import { HttpRequest } from "@smithy/protocol-http";
 import type { SerdeContext } from "@smithy/types";
+import { HttpRequest } from "./protocol-http/httpRequest";
 /**
- * @internal
  * used in code-generated serde.
+ *
+ * @internal
  */
 export declare function requestBuilder(input: any, context: SerdeContext): RequestBuilder;
 /**

package/node_modules/@smithy/core/dist-types/submodules/protocols/url-parser/parseUrl.d.ts

@@ -0,0 +1,5 @@
+import type { UrlParser } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const parseUrl: UrlParser;

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

@@ -0,0 +1,26 @@
+export { isRetryableByTrait, isClockSkewError, isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError, isNodeJsHttp2TransientError, } from "./service-error-classification/service-error-classification";
+export { AdaptiveRetryStrategy, type AdaptiveRetryStrategyOptions } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter, type DefaultRateLimiterOptions } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy, type StandardRetryStrategyOptions } from "./util-retry/StandardRetryStrategy";
+export { RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "./util-retry/config";
+export { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER, } from "./util-retry/constants";
+export type { RateLimiter } from "./util-retry/types";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, type AdaptiveRetryStrategyOptions as DeprecatedAdaptiveRetryStrategyOptions, } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, type StandardRetryStrategyOptions as DeprecatedStandardRetryStrategyOptions, } from "./middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy";
+export { defaultDelayDecider } from "./middleware-retry/retry-pre-sra-deprecated/delayDecider";
+export { defaultRetryDecider } from "./middleware-retry/retry-pre-sra-deprecated/retryDecider";
+export declare const ENV_MAX_ATTEMPTS: symbol;
+export declare const CONFIG_MAX_ATTEMPTS: symbol;
+export declare const NODE_MAX_ATTEMPT_CONFIG_OPTIONS: symbol;
+export declare const ENV_RETRY_MODE: symbol;
+export declare const CONFIG_RETRY_MODE: symbol;
+export declare const NODE_RETRY_MODE_CONFIG_OPTIONS: symbol;
+export { resolveRetryConfig } from "./middleware-retry/configurations";
+export type { RetryInputConfig, RetryResolvedConfig, PreviouslyResolved } from "./middleware-retry/configurations";
+export { omitRetryHeadersMiddleware, omitRetryHeadersMiddlewareOptions, getOmitRetryHeadersPlugin, } from "./middleware-retry/omitRetryHeadersMiddleware";
+export { retryMiddlewareOptions } from "./middleware-retry/retryMiddleware";
+export { getRetryAfterHint } from "./middleware-retry/parseRetryAfterHeader";
+export declare const retryMiddleware: (options: import("./middleware-retry/configurations").RetryResolvedConfig) => <Output extends import("@smithy/types").MetadataBearer = import("@smithy/types").MetadataBearer>(next: import("@smithy/types").FinalizeHandler<any, Output>, context: import("@smithy/types").HandlerExecutionContext) => import("@smithy/types").FinalizeHandler<any, Output>;
+export declare const getRetryPlugin: (options: import("./middleware-retry/configurations").RetryResolvedConfig) => import("@smithy/types").Pluggable<any, any>;

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

@@ -0,0 +1,20 @@
+export { isRetryableByTrait, isClockSkewError, isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError, isNodeJsHttp2TransientError, } from "./service-error-classification/service-error-classification";
+export { AdaptiveRetryStrategy, type AdaptiveRetryStrategyOptions } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter, type DefaultRateLimiterOptions } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy, type StandardRetryStrategyOptions } from "./util-retry/StandardRetryStrategy";
+export { RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "./util-retry/config";
+export { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER, } from "./util-retry/constants";
+export type { RateLimiter } from "./util-retry/types";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, type AdaptiveRetryStrategyOptions as DeprecatedAdaptiveRetryStrategyOptions, } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, type StandardRetryStrategyOptions as DeprecatedStandardRetryStrategyOptions, } from "./middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy";
+export { defaultDelayDecider } from "./middleware-retry/retry-pre-sra-deprecated/delayDecider";
+export { defaultRetryDecider } from "./middleware-retry/retry-pre-sra-deprecated/retryDecider";
+export { ENV_MAX_ATTEMPTS, CONFIG_MAX_ATTEMPTS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, ENV_RETRY_MODE, CONFIG_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, resolveRetryConfig, } from "./middleware-retry/configurations";
+export type { RetryInputConfig, RetryResolvedConfig, PreviouslyResolved } from "./middleware-retry/configurations";
+export { omitRetryHeadersMiddleware, omitRetryHeadersMiddlewareOptions, getOmitRetryHeadersPlugin, } from "./middleware-retry/omitRetryHeadersMiddleware";
+export { retryMiddlewareOptions } from "./middleware-retry/retryMiddleware";
+export { getRetryAfterHint } from "./middleware-retry/parseRetryAfterHeader";
+export declare const retryMiddleware: (options: import("./middleware-retry/configurations").RetryResolvedConfig) => <Output extends import("@smithy/types").MetadataBearer = import("@smithy/types").MetadataBearer>(next: import("@smithy/types").FinalizeHandler<any, Output>, context: import("@smithy/types").HandlerExecutionContext) => import("@smithy/types").FinalizeHandler<any, Output>;
+export declare const getRetryPlugin: (options: import("./middleware-retry/configurations").RetryResolvedConfig) => import("@smithy/types").Pluggable<any, any>;

package/node_modules/@smithy/core/dist-types/submodules/retry/middleware-retry/configurations.d.ts

@@ -0,0 +1,68 @@
+import type { LoadedConfigSelectors } from "@smithy/core/config";
+import type { Logger, Provider, RetryStrategy, RetryStrategyV2 } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+/**
+ * @internal
+ */
+export declare const CONFIG_MAX_ATTEMPTS = "max_attempts";
+/**
+ * @internal
+ */
+export declare const NODE_MAX_ATTEMPT_CONFIG_OPTIONS: LoadedConfigSelectors<number>;
+/**
+ * @public
+ */
+export interface RetryInputConfig {
+    /**
+     * The maximum number of times requests that encounter retryable failures should be attempted.
+     */
+    maxAttempts?: number | Provider<number>;
+    /**
+     * The strategy to retry the request. Using built-in exponential backoff strategy by default.
+     */
+    retryStrategy?: RetryStrategy | RetryStrategyV2;
+}
+/**
+ * @internal
+ */
+export interface PreviouslyResolved {
+    /**
+     * Specifies provider for retry algorithm to use.
+     * @internal
+     */
+    retryMode: string | Provider<string>;
+    logger?: Logger;
+}
+/**
+ * @internal
+ */
+export interface RetryResolvedConfig {
+    /**
+     * Resolved value for input config {@link RetryInputConfig.maxAttempts}
+     */
+    maxAttempts: Provider<number>;
+    /**
+     * Resolved value for input config {@link RetryInputConfig.retryStrategy}
+     */
+    retryStrategy: Provider<RetryStrategyV2 | RetryStrategy>;
+    logger?: Logger;
+}
+/**
+ * @internal
+ */
+export declare const resolveRetryConfig: <T>(input: T & PreviouslyResolved & RetryInputConfig) => T & RetryResolvedConfig;
+/**
+ * @internal
+ */
+export declare const ENV_RETRY_MODE = "AWS_RETRY_MODE";
+/**
+ * @internal
+ */
+export declare const CONFIG_RETRY_MODE = "retry_mode";
+/**
+ * @internal
+ */
+export declare const NODE_RETRY_MODE_CONFIG_OPTIONS: LoadedConfigSelectors<string>;

package/node_modules/@smithy/core/dist-types/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.browser.d.ts

@@ -0,0 +1,5 @@
+import type { HttpRequest } from "@smithy/core/protocols";
+/**
+ * @internal
+ */
+export declare const isStreamingPayload: (request: HttpRequest) => boolean;

package/node_modules/@smithy/core/dist-types/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.d.ts

@@ -0,0 +1,5 @@
+import type { HttpRequest } from "@smithy/core/protocols";
+/**
+ * @internal
+ */
+export declare const isStreamingPayload: (request: HttpRequest) => boolean;

package/node_modules/@smithy/core/dist-types/submodules/retry/middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy.d.ts

@@ -0,0 +1,23 @@
+import type { FinalizeHandler, FinalizeHandlerArguments, MetadataBearer, Provider } from "@smithy/types";
+import type { RateLimiter } from "../../util-retry/types";
+import { StandardRetryStrategy, type StandardRetryStrategyOptions } from "./StandardRetryStrategy";
+/**
+ * Strategy options to be passed to AdaptiveRetryStrategy
+ * @public
+ * @deprecated replaced by \@smithy/util-retry (SRA).
+ */
+export interface AdaptiveRetryStrategyOptions extends StandardRetryStrategyOptions {
+    rateLimiter?: RateLimiter;
+}
+/**
+ * @public
+ * @deprecated use AdaptiveRetryStrategy from @smithy/util-retry
+ */
+export declare class AdaptiveRetryStrategy extends StandardRetryStrategy {
+    private rateLimiter;
+    constructor(maxAttemptsProvider: Provider<number>, options?: AdaptiveRetryStrategyOptions);
+    retry<Input extends object, Ouput extends MetadataBearer>(next: FinalizeHandler<Input, Ouput>, args: FinalizeHandlerArguments<Input>): Promise<{
+        response: unknown;
+        output: Ouput;
+    }>;
+}

package/node_modules/@smithy/core/dist-types/submodules/retry/middleware-retry/retryMiddleware.d.ts

@@ -0,0 +1,19 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import type { AbsoluteLocation, FinalizeHandler, FinalizeRequestHandlerOptions, HandlerExecutionContext, MetadataBearer, Pluggable } from "@smithy/types";
+import type { RetryResolvedConfig } from "./configurations";
+/**
+ * @internal
+ */
+export type IsStreamingPayload = (request: HttpRequest) => boolean;
+/**
+ * @internal
+ */
+export declare function bindRetryMiddleware(isStreamingPayload: IsStreamingPayload): (options: RetryResolvedConfig) => <Output extends MetadataBearer = MetadataBearer>(next: FinalizeHandler<any, Output>, context: HandlerExecutionContext) => FinalizeHandler<any, Output>;
+/**
+ * @internal
+ */
+export declare const retryMiddlewareOptions: FinalizeRequestHandlerOptions & AbsoluteLocation;
+/**
+ * @internal
+ */
+export declare function bindGetRetryPlugin(isStreamingPayload: IsStreamingPayload): (options: RetryResolvedConfig) => Pluggable<any, any>;