@cdk8s/awscdk-resolver 0.0.625 → 0.0.627

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

@@ -0,0 +1,13 @@
+import { CodecSettings, Schema, ShapeDeserializer } from "@smithy/types";
+import { SerdeContext } from "../SerdeContext";
+/**
+ * This deserializer reads strings.
+ *
+ * @public
+ */
+export declare class FromStringShapeDeserializer extends SerdeContext implements ShapeDeserializer<string> {
+    private settings;
+    constructor(settings: CodecSettings);
+    read(_schema: Schema, data: string): any;
+    private base64ToUtf8;
+}

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

@@ -0,0 +1,21 @@
+import { CodecSettings, Schema, SerdeFunctions, ShapeDeserializer } from "@smithy/types";
+import { SerdeContext } from "../SerdeContext";
+/**
+ * This deserializer is a dispatcher that decides whether to use a string deserializer
+ * or a codec deserializer based on HTTP traits.
+ *
+ * For example, in a JSON HTTP message, the deserialization of a field will differ depending on whether
+ * it is bound to the HTTP header (string) or body (JSON).
+ *
+ * @public
+ */
+export declare class HttpInterceptingShapeDeserializer<CodecShapeDeserializer extends ShapeDeserializer<any>> extends SerdeContext implements ShapeDeserializer<string | Uint8Array> {
+    private codecDeserializer;
+    private stringDeserializer;
+    constructor(codecDeserializer: CodecShapeDeserializer, codecSettings: CodecSettings);
+    /**
+     * @override
+     */
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    read(schema: Schema, data: string | Uint8Array): any | Promise<any>;
+}

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

@@ -0,0 +1,23 @@
+import { CodecSettings, ConfigurableSerdeContext, Schema as ISchema, SerdeFunctions, ShapeSerializer } from "@smithy/types";
+import { ToStringShapeSerializer } from "./ToStringShapeSerializer";
+/**
+ * This serializer decides whether to dispatch to a string serializer or a codec serializer
+ * depending on HTTP binding traits within the given schema.
+ *
+ * For example, a JavaScript array is serialized differently when being written
+ * to a REST JSON HTTP header (comma-delimited string) and a REST JSON HTTP body (JSON array).
+ *
+ * @public
+ */
+export declare class HttpInterceptingShapeSerializer<CodecShapeSerializer extends ShapeSerializer<string | Uint8Array>> implements ShapeSerializer<string | Uint8Array>, ConfigurableSerdeContext {
+    private codecSerializer;
+    private stringSerializer;
+    private buffer;
+    constructor(codecSerializer: CodecShapeSerializer, codecSettings: CodecSettings, stringSerializer?: ToStringShapeSerializer);
+    /**
+     * @override
+     */
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    write(schema: ISchema, value: unknown): void;
+    flush(): string | Uint8Array;
+}

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

@@ -0,0 +1,14 @@
+import { CodecSettings, Schema, ShapeSerializer } from "@smithy/types";
+import { SerdeContext } from "../SerdeContext";
+/**
+ * Serializes a shape to string.
+ *
+ * @public
+ */
+export declare class ToStringShapeSerializer extends SerdeContext implements ShapeSerializer<string> {
+    private settings;
+    private stringBuffer;
+    constructor(settings: CodecSettings);
+    write(schema: Schema, value: unknown): void;
+    flush(): string;
+}

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

@@ -0,0 +1,9 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { CodecSettings, TimestampDateTimeSchema, TimestampEpochSecondsSchema, TimestampHttpDateSchema } from "@smithy/types";
+/**
+ * Assuming the schema is a timestamp type, the function resolves the format using
+ * either the timestamp's own traits, or the default timestamp format from the CodecSettings.
+ *
+ * @internal
+ */
+export declare function determineTimestampFormat(ns: NormalizedSchema, settings: CodecSettings): TimestampDateTimeSchema | TimestampHttpDateSchema | TimestampEpochSecondsSchema;

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

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const escapeUriPath: (uri: string) => string;

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

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const escapeUri: (uri: string) => string;

package/node_modules/@smithy/core/dist-types/ts3.4/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, AdaptiveRetryStrategyOptions } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter, DefaultRateLimiterOptions } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy, 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 { RateLimiter } from "./util-retry/types";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, AdaptiveRetryStrategyOptions as DeprecatedAdaptiveRetryStrategyOptions } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, 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 { 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/ts3.4/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, AdaptiveRetryStrategyOptions } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter, DefaultRateLimiterOptions } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy, 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 { RateLimiter } from "./util-retry/types";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, AdaptiveRetryStrategyOptions as DeprecatedAdaptiveRetryStrategyOptions } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, 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 { 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/ts3.4/submodules/retry/middleware-retry/configurations.d.ts

@@ -0,0 +1,71 @@
+import { LoadedConfigSelectors } from "@smithy/core/config";
+import { 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, defaults?: {
+    defaultMaxAttempts?: number;
+    defaultBaseDelay?: number;
+}) => 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/ts3.4/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.browser.d.ts

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

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

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

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

@@ -0,0 +1,15 @@
+import { HandlerExecutionContext, InitializeHandler, InitializeHandlerOptions, MetadataBearer, Pluggable } from "@smithy/types";
+import { RetryResolvedConfig } from "./configurations";
+/**
+ * This middleware is attached to operations designated as long-polling.
+ * @internal
+ */
+export declare const longPollMiddleware: () => <Output extends MetadataBearer = MetadataBearer>(next: InitializeHandler<any, Output>, context: HandlerExecutionContext) => InitializeHandler<any, Output>;
+/**
+ * @internal
+ */
+export declare const longPollMiddlewareOptions: InitializeHandlerOptions;
+/**
+ * @internal
+ */
+export declare const getLongPollPlugin: (options: RetryResolvedConfig) => Pluggable<any, any>;

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

@@ -0,0 +1,15 @@
+import { FinalizeHandler, MetadataBearer, Pluggable, RelativeMiddlewareOptions } from "@smithy/types";
+/**
+ * This is still in use.
+ * See AddOmitRetryHeadersDependency.java.
+ * @internal
+ */
+export declare const omitRetryHeadersMiddleware: () => <Output extends MetadataBearer = MetadataBearer>(next: FinalizeHandler<any, Output>) => FinalizeHandler<any, Output>;
+/**
+ * @internal
+ */
+export declare const omitRetryHeadersMiddlewareOptions: RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+export declare const getOmitRetryHeadersPlugin: (options: unknown) => Pluggable<any, any>;

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

@@ -0,0 +1,10 @@
+import { Logger } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare function parseRetryAfterHeader(response: unknown, logger?: Logger): Date | undefined;
+/**
+ * Backwards-compatibility alias.
+ * @internal
+ */
+export declare function getRetryAfterHint(response: unknown, logger?: Logger): Date | undefined;

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

@@ -0,0 +1,23 @@
+import { FinalizeHandler, FinalizeHandlerArguments, MetadataBearer, Provider } from "@smithy/types";
+import { RateLimiter } from "../../util-retry/types";
+import { StandardRetryStrategy, 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/ts3.4/submodules/retry/middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy.d.ts

@@ -0,0 +1,33 @@
+import { FinalizeHandler, FinalizeHandlerArguments, MetadataBearer, Provider, RetryStrategy } from "@smithy/types";
+import { DelayDecider, RetryDecider, RetryQuota } from "./types";
+/**
+ * Strategy options to be passed to StandardRetryStrategy
+ * @public
+ * @deprecated use StandardRetryStrategy from @smithy/util-retry
+ */
+export interface StandardRetryStrategyOptions {
+    retryDecider?: RetryDecider;
+    delayDecider?: DelayDecider;
+    retryQuota?: RetryQuota;
+}
+/**
+ * @public
+ * @deprecated use StandardRetryStrategy from @smithy/util-retry
+ */
+export declare class StandardRetryStrategy implements RetryStrategy {
+    private readonly maxAttemptsProvider;
+    private retryDecider;
+    private delayDecider;
+    private retryQuota;
+    mode: string;
+    constructor(maxAttemptsProvider: Provider<number>, options?: StandardRetryStrategyOptions);
+    private shouldRetry;
+    private getMaxAttempts;
+    retry<Input extends object, Ouput extends MetadataBearer>(next: FinalizeHandler<Input, Ouput>, args: FinalizeHandlerArguments<Input>, options?: {
+        beforeRequest: Function;
+        afterRequest: Function;
+    }): Promise<{
+        response: unknown;
+        output: Ouput;
+    }>;
+}

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

@@ -0,0 +1,26 @@
+import { RetryQuota } from "./types";
+/**
+ * @internal
+ * @deprecated replaced by \@smithy/util-retry (SRA).
+ */
+export interface DefaultRetryQuotaOptions {
+    /**
+     * The total amount of retry token to be incremented from retry token balance
+     * if an SDK operation invocation succeeds without requiring a retry request.
+     */
+    noRetryIncrement?: number;
+    /**
+     * The total amount of retry tokens to be decremented from retry token balance.
+     */
+    retryCost?: number;
+    /**
+     * The total amount of retry tokens to be decremented from retry token balance
+     * when a throttling error is encountered.
+     */
+    timeoutRetryCost?: number;
+}
+/**
+ * @internal
+ * @deprecated replaced by \@smithy/util-retry (SRA).
+ */
+export declare const getDefaultRetryQuota: (initialRetryTokens: number, options?: DefaultRetryQuotaOptions) => RetryQuota;

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

@@ -0,0 +1,6 @@
+/**
+ * Calculate a capped, fully-jittered exponential backoff time.
+ * @internal
+ * @deprecated replaced by \@smithy/util-retry (SRA).
+ */
+export declare const defaultDelayDecider: (delayBase: number, attempts: number) => number;

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

@@ -0,0 +1,6 @@
+import { SdkError } from "@smithy/types";
+/**
+ * @internal
+ * @deprecated this is only used in the deprecated StandardRetryStrategy. Do not use in new code.
+ */
+export declare const defaultRetryDecider: (error: SdkError) => boolean;

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

@@ -0,0 +1,65 @@
+import { SdkError } from "@smithy/types";
+/**
+ * Determines whether an error is retryable based on the number of retries
+ * already attempted, the HTTP status code, and the error received (if any).
+ *
+ * @param error - The error encountered.
+ *
+ * @deprecated
+ * @internal
+ */
+export interface RetryDecider {
+    (error: SdkError): boolean;
+}
+/**
+ * Determines the number of milliseconds to wait before retrying an action.
+ *
+ * @param delayBase - The base delay (in milliseconds).
+ * @param attempts - The number of times the action has already been tried.
+ *
+ * @deprecated
+ * @internal
+ */
+export interface DelayDecider {
+    (delayBase: number, attempts: number): number;
+}
+/**
+ * Interface that specifies the retry quota behavior.
+ * @deprecated
+ * @internal
+ */
+export interface RetryQuota {
+    /**
+     * returns true if retry tokens are available from the retry quota bucket.
+     */
+    hasRetryTokens: (error: SdkError) => boolean;
+    /**
+     * returns token amount from the retry quota bucket.
+     * throws error is retry tokens are not available.
+     */
+    retrieveRetryTokens: (error: SdkError) => number;
+    /**
+     * releases tokens back to the retry quota.
+     */
+    releaseRetryTokens: (releaseCapacityAmount?: number) => void;
+}
+/**
+ * @deprecated
+ * @internal
+ */
+export interface RateLimiter {
+    /**
+     * If there is sufficient capacity (tokens) available, it immediately returns.
+     * If there is not sufficient capacity, it will either sleep a certain amount
+     * of time until the rate limiter can retrieve a token from its token bucket
+     * or raise an exception indicating there is insufficient capacity.
+     */
+    getSendToken: () => Promise<void>;
+    /**
+     * Updates the client sending rate based on response.
+     * If the response was successful, the capacity and fill rate are increased.
+     * If the response was a throttling response, the capacity and fill rate are
+     * decreased. Transient errors do not affect the rate limiter.
+     */
+    updateClientSendingRate: (response: any) => void;
+}

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

@@ -0,0 +1,19 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import { AbsoluteLocation, FinalizeHandler, FinalizeRequestHandlerOptions, HandlerExecutionContext, MetadataBearer, Pluggable } from "@smithy/types";
+import { 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>;

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

@@ -0,0 +1,2 @@
+import { SdkError } from "@smithy/types";
+export declare const asSdkError: (error: unknown) => SdkError;

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

@@ -0,0 +1,30 @@
+/**
+ * Errors encountered when the client clock and server clock cannot agree on the
+ * current time.
+ *
+ * These errors are retryable, assuming the SDK has enabled clock skew
+ * correction.
+ */
+export declare const CLOCK_SKEW_ERROR_CODES: string[];
+/**
+ * Errors that indicate the SDK is being throttled.
+ *
+ * These errors are always retryable.
+ */
+export declare const THROTTLING_ERROR_CODES: string[];
+/**
+ * Error codes that indicate transient issues
+ */
+export declare const TRANSIENT_ERROR_CODES: string[];
+/**
+ * Error codes that indicate transient issues
+ */
+export declare const TRANSIENT_ERROR_STATUS_CODES: number[];
+/**
+ * Node.js system error codes that indicate timeout.
+ */
+export declare const NODEJS_TIMEOUT_ERROR_CODES: string[];
+/**
+ * Node.js system error codes that indicate network error.
+ */
+export declare const NODEJS_NETWORK_ERROR_CODES: string[];

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

@@ -0,0 +1,30 @@
+import { SdkError } from "@smithy/types";
+export declare const isRetryableByTrait: (error: SdkError) => boolean;
+/**
+ * @deprecated use isClockSkewCorrectedError. This is only used in deprecated code.
+ */
+export declare const isClockSkewError: (error: SdkError) => boolean;
+/**
+ * @returns whether the error resulted in a systemClockOffset aka clock skew correction.
+ */
+export declare const isClockSkewCorrectedError: (error: SdkError) => true | undefined;
+/**
+ *
+ * @internal
+ */
+export declare const isBrowserNetworkError: (error: SdkError) => boolean;
+export declare const isThrottlingError: (error: SdkError) => boolean;
+/**
+ * Though NODEJS_TIMEOUT_ERROR_CODES are platform specific, they are
+ * included here because there is an error scenario with unknown root
+ * cause where the NodeHttpHandler does not decorate the Error with
+ * the name "TimeoutError" to be checked by the TRANSIENT_ERROR_CODES condition.
+ */
+export declare const isTransientError: (error: SdkError, depth?: number) => boolean;
+export declare const isServerError: (error: SdkError) => boolean;
+/**
+ * @internal
+ */
+export declare function isNodeJsHttp2TransientError(error: Error & {
+    code?: string;
+}): boolean;

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

@@ -0,0 +1,38 @@
+import { Provider, RetryErrorInfo, RetryStrategyV2, RetryToken, StandardRetryToken } from "@smithy/types";
+import { StandardRetryStrategyOptions } from "./StandardRetryStrategy";
+import { RateLimiter } from "./types";
+/**
+ * Strategy options to be passed to AdaptiveRetryStrategy
+ *
+ * @public
+ */
+export interface AdaptiveRetryStrategyOptions extends Partial<StandardRetryStrategyOptions> {
+    rateLimiter?: RateLimiter;
+}
+/**
+ * The AdaptiveRetryStrategy is a retry strategy for executing against a very
+ * resource constrained set of resources. Care should be taken when using this
+ * retry strategy. By default, it uses a dynamic backoff delay based on load
+ * currently perceived against the downstream resource and performs circuit
+ * breaking to disable retries in the event of high downstream failures using
+ * the DefaultRateLimiter.
+ *
+ * @public
+ *
+ * @see {@link StandardRetryStrategy}
+ * @see {@link DefaultRateLimiter }
+ */
+export declare class AdaptiveRetryStrategy implements RetryStrategyV2 {
+    readonly mode: string;
+    private rateLimiter;
+    private standardRetryStrategy;
+    constructor(maxAttemptsProvider: number | Provider<number>, options?: AdaptiveRetryStrategyOptions);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
+    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+    /**
+     * There is an existing integration which accesses this field.
+     * @deprecated
+     */
+    maxAttemptsProvider(): Promise<number>;
+}

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

@@ -0,0 +1,31 @@
+import { Provider, RetryBackoffStrategy, RetryStrategyV2 } from "@smithy/types";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+/**
+ * This extension of the StandardRetryStrategy allows customizing the
+ * backoff computation.
+ *
+ * @public
+ */
+export declare class ConfiguredRetryStrategy extends StandardRetryStrategy implements RetryStrategyV2 {
+    private readonly computeNextBackoffDelay;
+    /**
+     * @param maxAttempts - the maximum number of retry attempts allowed.
+     *                      e.g., if set to 3, then 4 total requests are possible.
+     * @param computeNextBackoffDelay - a millisecond delay for each retry or a function that takes the retry attempt
+     *                                  and returns the delay.
+     *
+     * @example exponential backoff.
+     * ```js
+     * new Client({
+     *   retryStrategy: new ConfiguredRetryStrategy(3, (attempt) => attempt ** 2)
+     * });
+     * ```
+     * @example constant delay.
+     * ```js
+     * new Client({
+     *   retryStrategy: new ConfiguredRetryStrategy(3, 2000)
+     * });
+     * ```
+     */
+    constructor(maxAttempts: number | Provider<number>, computeNextBackoffDelay?: number | RetryBackoffStrategy["computeNextBackoffDelay"]);
+}