@rio-cloud/cdk-v2-constructs 7.14.0-alpha.2 → 7.14.0

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js

@@ -0,0 +1,109 @@
+import { isThrottlingError } from "@smithy/service-error-classification";
+export class DefaultRateLimiter {
+    static setTimeoutFn = setTimeout;
+    beta;
+    minCapacity;
+    minFillRate;
+    scaleConstant;
+    smooth;
+    currentCapacity = 0;
+    enabled = false;
+    lastMaxRate = 0;
+    measuredTxRate = 0;
+    requestCount = 0;
+    fillRate;
+    lastThrottleTime;
+    lastTimestamp = 0;
+    lastTxRateBucket;
+    maxCapacity;
+    timeWindow = 0;
+    constructor(options) {
+        this.beta = options?.beta ?? 0.7;
+        this.minCapacity = options?.minCapacity ?? 1;
+        this.minFillRate = options?.minFillRate ?? 0.5;
+        this.scaleConstant = options?.scaleConstant ?? 0.4;
+        this.smooth = options?.smooth ?? 0.8;
+        const currentTimeInSeconds = this.getCurrentTimeInSeconds();
+        this.lastThrottleTime = currentTimeInSeconds;
+        this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
+        this.fillRate = this.minFillRate;
+        this.maxCapacity = this.minCapacity;
+    }
+    getCurrentTimeInSeconds() {
+        return Date.now() / 1000;
+    }
+    async getSendToken() {
+        return this.acquireTokenBucket(1);
+    }
+    async acquireTokenBucket(amount) {
+        if (!this.enabled) {
+            return;
+        }
+        this.refillTokenBucket();
+        if (amount > this.currentCapacity) {
+            const delay = ((amount - this.currentCapacity) / this.fillRate) * 1000;
+            await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay));
+        }
+        this.currentCapacity = this.currentCapacity - amount;
+    }
+    refillTokenBucket() {
+        const timestamp = this.getCurrentTimeInSeconds();
+        if (!this.lastTimestamp) {
+            this.lastTimestamp = timestamp;
+            return;
+        }
+        const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
+        this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount);
+        this.lastTimestamp = timestamp;
+    }
+    updateClientSendingRate(response) {
+        let calculatedRate;
+        this.updateMeasuredRate();
+        if (isThrottlingError(response)) {
+            const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
+            this.lastMaxRate = rateToUse;
+            this.calculateTimeWindow();
+            this.lastThrottleTime = this.getCurrentTimeInSeconds();
+            calculatedRate = this.cubicThrottle(rateToUse);
+            this.enableTokenBucket();
+        }
+        else {
+            this.calculateTimeWindow();
+            calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
+        }
+        const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
+        this.updateTokenBucketRate(newRate);
+    }
+    calculateTimeWindow() {
+        this.timeWindow = this.getPrecise(Math.pow((this.lastMaxRate * (1 - this.beta)) / this.scaleConstant, 1 / 3));
+    }
+    cubicThrottle(rateToUse) {
+        return this.getPrecise(rateToUse * this.beta);
+    }
+    cubicSuccess(timestamp) {
+        return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
+    }
+    enableTokenBucket() {
+        this.enabled = true;
+    }
+    updateTokenBucketRate(newRate) {
+        this.refillTokenBucket();
+        this.fillRate = Math.max(newRate, this.minFillRate);
+        this.maxCapacity = Math.max(newRate, this.minCapacity);
+        this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity);
+    }
+    updateMeasuredRate() {
+        const t = this.getCurrentTimeInSeconds();
+        const timeBucket = Math.floor(t * 2) / 2;
+        this.requestCount++;
+        if (timeBucket > this.lastTxRateBucket) {
+            const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
+            this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
+            this.requestCount = 0;
+            this.lastTxRateBucket = timeBucket;
+        }
+    }
+    getPrecise(num) {
+        return parseFloat(num.toFixed(8));
+    }
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js

@@ -0,0 +1,67 @@
+import { DEFAULT_MAX_ATTEMPTS, RETRY_MODES } from "./config";
+import { DEFAULT_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, NO_RETRY_INCREMENT, RETRY_COST, THROTTLING_RETRY_DELAY_BASE, TIMEOUT_RETRY_COST, } from "./constants";
+import { getDefaultRetryBackoffStrategy } from "./defaultRetryBackoffStrategy";
+import { createDefaultRetryToken } from "./defaultRetryToken";
+export class StandardRetryStrategy {
+    maxAttempts;
+    mode = RETRY_MODES.STANDARD;
+    capacity = INITIAL_RETRY_TOKENS;
+    retryBackoffStrategy = getDefaultRetryBackoffStrategy();
+    maxAttemptsProvider;
+    constructor(maxAttempts) {
+        this.maxAttempts = maxAttempts;
+        this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts;
+    }
+    async acquireInitialRetryToken(retryTokenScope) {
+        return createDefaultRetryToken({
+            retryDelay: DEFAULT_RETRY_DELAY_BASE,
+            retryCount: 0,
+        });
+    }
+    async refreshRetryTokenForRetry(token, errorInfo) {
+        const maxAttempts = await this.getMaxAttempts();
+        if (this.shouldRetry(token, errorInfo, maxAttempts)) {
+            const errorType = errorInfo.errorType;
+            this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE);
+            const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
+            const retryDelay = errorInfo.retryAfterHint
+                ? Math.max(errorInfo.retryAfterHint.getTime() - Date.now() || 0, delayFromErrorType)
+                : delayFromErrorType;
+            const capacityCost = this.getCapacityCost(errorType);
+            this.capacity -= capacityCost;
+            return createDefaultRetryToken({
+                retryDelay,
+                retryCount: token.getRetryCount() + 1,
+                retryCost: capacityCost,
+            });
+        }
+        throw new Error("No retry token available");
+    }
+    recordSuccess(token) {
+        this.capacity = Math.max(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
+    }
+    getCapacity() {
+        return this.capacity;
+    }
+    async getMaxAttempts() {
+        try {
+            return await this.maxAttemptsProvider();
+        }
+        catch (error) {
+            console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
+            return DEFAULT_MAX_ATTEMPTS;
+        }
+    }
+    shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
+        const attempts = tokenToRenew.getRetryCount() + 1;
+        return (attempts < maxAttempts &&
+            this.capacity >= this.getCapacityCost(errorInfo.errorType) &&
+            this.isRetryableError(errorInfo.errorType));
+    }
+    getCapacityCost(errorType) {
+        return errorType === "TRANSIENT" ? TIMEOUT_RETRY_COST : RETRY_COST;
+    }
+    isRetryableError(errorType) {
+        return errorType === "THROTTLING" || errorType === "TRANSIENT";
+    }
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/config.js

@@ -0,0 +1,7 @@
+export var RETRY_MODES;
+(function (RETRY_MODES) {
+    RETRY_MODES["STANDARD"] = "standard";
+    RETRY_MODES["ADAPTIVE"] = "adaptive";
+})(RETRY_MODES || (RETRY_MODES = {}));
+export const DEFAULT_MAX_ATTEMPTS = 3;
+export const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/constants.js

@@ -0,0 +1,9 @@
+export const DEFAULT_RETRY_DELAY_BASE = 100;
+export const MAXIMUM_RETRY_DELAY = 20 * 1000;
+export const THROTTLING_RETRY_DELAY_BASE = 500;
+export const INITIAL_RETRY_TOKENS = 500;
+export const RETRY_COST = 5;
+export const TIMEOUT_RETRY_COST = 10;
+export const NO_RETRY_INCREMENT = 1;
+export const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+export const REQUEST_HEADER = "amz-sdk-request";

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js

@@ -0,0 +1,14 @@
+import { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY } from "./constants";
+export const getDefaultRetryBackoffStrategy = () => {
+    let delayBase = DEFAULT_RETRY_DELAY_BASE;
+    const computeNextBackoffDelay = (attempts) => {
+        return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
+    };
+    const setDelayBase = (delay) => {
+        delayBase = delay;
+    };
+    return {
+        computeNextBackoffDelay,
+        setDelayBase,
+    };
+};

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js

@@ -0,0 +1,11 @@
+import { MAXIMUM_RETRY_DELAY } from "./constants";
+export const createDefaultRetryToken = ({ retryDelay, retryCount, retryCost, }) => {
+    const getRetryCount = () => retryCount;
+    const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);
+    const getRetryCost = () => retryCost;
+    return {
+        getRetryCount,
+        getRetryDelay,
+        getRetryCost,
+    };
+};

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/index.js

@@ -0,0 +1,7 @@
+export * from "./AdaptiveRetryStrategy";
+export * from "./ConfiguredRetryStrategy";
+export * from "./DefaultRateLimiter";
+export * from "./StandardRetryStrategy";
+export * from "./config";
+export * from "./constants";
+export * from "./types";

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-es/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/AdaptiveRetryStrategy.d.ts

@@ -0,0 +1,33 @@
+import type { Provider, RetryErrorInfo, RetryStrategyV2, RetryToken, StandardRetryToken } from "@smithy/types";
+import type { RateLimiter } from "./types";
+/**
+ * @public
+ *
+ * Strategy options to be passed to AdaptiveRetryStrategy
+ */
+export interface AdaptiveRetryStrategyOptions {
+    rateLimiter?: RateLimiter;
+}
+/**
+ * @public
+ *
+ * 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.
+ *
+ * @see {@link StandardRetryStrategy}
+ * @see {@link DefaultRateLimiter }
+ */
+export declare class AdaptiveRetryStrategy implements RetryStrategyV2 {
+    private readonly maxAttemptsProvider;
+    private rateLimiter;
+    private standardRetryStrategy;
+    readonly mode: string;
+    constructor(maxAttemptsProvider: Provider<number>, options?: AdaptiveRetryStrategyOptions);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
+    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/ConfiguredRetryStrategy.d.ts

@@ -0,0 +1,32 @@
+import type { Provider, RetryBackoffStrategy, RetryErrorInfo, RetryStrategyV2, StandardRetryToken } from "@smithy/types";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+/**
+ * @public
+ *
+ * This extension of the StandardRetryStrategy allows customizing the
+ * backoff computation.
+ */
+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"]);
+    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<StandardRetryToken>;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/DefaultRateLimiter.d.ts

@@ -0,0 +1,49 @@
+import type { RateLimiter } from "./types";
+/**
+ * @public
+ */
+export interface DefaultRateLimiterOptions {
+    beta?: number;
+    minCapacity?: number;
+    minFillRate?: number;
+    scaleConstant?: number;
+    smooth?: number;
+}
+/**
+ * @public
+ */
+export declare class DefaultRateLimiter implements RateLimiter {
+    /**
+     * Only used in testing.
+     */
+    private static setTimeoutFn;
+    private beta;
+    private minCapacity;
+    private minFillRate;
+    private scaleConstant;
+    private smooth;
+    private currentCapacity;
+    private enabled;
+    private lastMaxRate;
+    private measuredTxRate;
+    private requestCount;
+    private fillRate;
+    private lastThrottleTime;
+    private lastTimestamp;
+    private lastTxRateBucket;
+    private maxCapacity;
+    private timeWindow;
+    constructor(options?: DefaultRateLimiterOptions);
+    private getCurrentTimeInSeconds;
+    getSendToken(): Promise<void>;
+    private acquireTokenBucket;
+    private refillTokenBucket;
+    updateClientSendingRate(response: any): void;
+    private calculateTimeWindow;
+    private cubicThrottle;
+    private cubicSuccess;
+    private enableTokenBucket;
+    private updateTokenBucketRate;
+    private updateMeasuredRate;
+    private getPrecise;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/StandardRetryStrategy.d.ts

@@ -0,0 +1,26 @@
+import type { Provider, RetryErrorInfo, RetryStrategyV2, StandardRetryToken } from "@smithy/types";
+/**
+ * @public
+ */
+export declare class StandardRetryStrategy implements RetryStrategyV2 {
+    private readonly maxAttempts;
+    readonly mode: string;
+    private capacity;
+    private readonly retryBackoffStrategy;
+    private readonly maxAttemptsProvider;
+    constructor(maxAttempts: number);
+    constructor(maxAttemptsProvider: Provider<number>);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<StandardRetryToken>;
+    refreshRetryTokenForRetry(token: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<StandardRetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+    /**
+     * @returns the current available retry capacity.
+     *
+     * This number decreases when retries are executed and refills when requests or retries succeed.
+     */
+    getCapacity(): number;
+    private getMaxAttempts;
+    private shouldRetry;
+    private getCapacityCost;
+    private isRetryableError;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @public
+ */
+export declare enum RETRY_MODES {
+    STANDARD = "standard",
+    ADAPTIVE = "adaptive"
+}
+/**
+ * @public
+ *
+ * The default value for how many HTTP requests an SDK should make for a
+ * single SDK operation invocation before giving up
+ */
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * @public
+ *
+ * The default retry algorithm to use.
+ */
+export declare const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/constants.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @public
+ *
+ * The base number of milliseconds to use in calculating a suitable cool-down
+ * time when a retryable error is encountered.
+ */
+export declare const DEFAULT_RETRY_DELAY_BASE = 100;
+/**
+ * @public
+ *
+ * The maximum amount of time (in milliseconds) that will be used as a delay
+ * between retry attempts.
+ */
+export declare const MAXIMUM_RETRY_DELAY: number;
+/**
+ * @public
+ *
+ * The retry delay base (in milliseconds) to use when a throttling error is
+ * encountered.
+ */
+export declare const THROTTLING_RETRY_DELAY_BASE = 500;
+/**
+ * @public
+ *
+ * Initial number of retry tokens in Retry Quota
+ */
+export declare const INITIAL_RETRY_TOKENS = 500;
+/**
+ * @public
+ *
+ * The total amount of retry tokens to be decremented from retry token balance.
+ */
+export declare const RETRY_COST = 5;
+/**
+ * @public
+ *
+ * The total amount of retry tokens to be decremented from retry token balance
+ * when a throttling error is encountered.
+ */
+export declare const TIMEOUT_RETRY_COST = 10;
+/**
+ * @public
+ *
+ * The total amount of retry token to be incremented from retry token balance
+ * if an SDK operation invocation succeeds without requiring a retry request.
+ */
+export declare const NO_RETRY_INCREMENT = 1;
+/**
+ * @public
+ *
+ * Header name for SDK invocation ID
+ */
+export declare const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+/**
+ * @public
+ *
+ * Header name for request retry information.
+ */
+export declare const REQUEST_HEADER = "amz-sdk-request";

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/defaultRetryBackoffStrategy.d.ts

@@ -0,0 +1,5 @@
+import type { StandardRetryBackoffStrategy } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const getDefaultRetryBackoffStrategy: () => StandardRetryBackoffStrategy;

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/defaultRetryToken.d.ts

@@ -0,0 +1,9 @@
+import type { StandardRetryToken } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const createDefaultRetryToken: ({ retryDelay, retryCount, retryCost, }: {
+    retryDelay: number;
+    retryCount: number;
+    retryCost?: number;
+}) => StandardRetryToken;

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AdaptiveRetryStrategy";
+export * from "./ConfiguredRetryStrategy";
+export * from "./DefaultRateLimiter";
+export * from "./StandardRetryStrategy";
+export * from "./config";
+export * from "./constants";
+export * from "./types";

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/ts3.4/AdaptiveRetryStrategy.d.ts

@@ -0,0 +1,33 @@
+import { Provider, RetryErrorInfo, RetryStrategyV2, RetryToken, StandardRetryToken } from "@smithy/types";
+import { RateLimiter } from "./types";
+/**
+ * @public
+ *
+ * Strategy options to be passed to AdaptiveRetryStrategy
+ */
+export interface AdaptiveRetryStrategyOptions {
+    rateLimiter?: RateLimiter;
+}
+/**
+ * @public
+ *
+ * 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.
+ *
+ * @see {@link StandardRetryStrategy}
+ * @see {@link DefaultRateLimiter }
+ */
+export declare class AdaptiveRetryStrategy implements RetryStrategyV2 {
+    private readonly maxAttemptsProvider;
+    private rateLimiter;
+    private standardRetryStrategy;
+    readonly mode: string;
+    constructor(maxAttemptsProvider: Provider<number>, options?: AdaptiveRetryStrategyOptions);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
+    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/ts3.4/ConfiguredRetryStrategy.d.ts

@@ -0,0 +1,32 @@
+import { Provider, RetryBackoffStrategy, RetryErrorInfo, RetryStrategyV2, StandardRetryToken } from "@smithy/types";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+/**
+ * @public
+ *
+ * This extension of the StandardRetryStrategy allows customizing the
+ * backoff computation.
+ */
+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"]);
+    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<StandardRetryToken>;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/ts3.4/DefaultRateLimiter.d.ts

@@ -0,0 +1,49 @@
+import { RateLimiter } from "./types";
+/**
+ * @public
+ */
+export interface DefaultRateLimiterOptions {
+    beta?: number;
+    minCapacity?: number;
+    minFillRate?: number;
+    scaleConstant?: number;
+    smooth?: number;
+}
+/**
+ * @public
+ */
+export declare class DefaultRateLimiter implements RateLimiter {
+    /**
+     * Only used in testing.
+     */
+    private static setTimeoutFn;
+    private beta;
+    private minCapacity;
+    private minFillRate;
+    private scaleConstant;
+    private smooth;
+    private currentCapacity;
+    private enabled;
+    private lastMaxRate;
+    private measuredTxRate;
+    private requestCount;
+    private fillRate;
+    private lastThrottleTime;
+    private lastTimestamp;
+    private lastTxRateBucket;
+    private maxCapacity;
+    private timeWindow;
+    constructor(options?: DefaultRateLimiterOptions);
+    private getCurrentTimeInSeconds;
+    getSendToken(): Promise<void>;
+    private acquireTokenBucket;
+    private refillTokenBucket;
+    updateClientSendingRate(response: any): void;
+    private calculateTimeWindow;
+    private cubicThrottle;
+    private cubicSuccess;
+    private enableTokenBucket;
+    private updateTokenBucketRate;
+    private updateMeasuredRate;
+    private getPrecise;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/ts3.4/StandardRetryStrategy.d.ts

@@ -0,0 +1,26 @@
+import { Provider, RetryErrorInfo, RetryStrategyV2, StandardRetryToken } from "@smithy/types";
+/**
+ * @public
+ */
+export declare class StandardRetryStrategy implements RetryStrategyV2 {
+    private readonly maxAttempts;
+    readonly mode: string;
+    private capacity;
+    private readonly retryBackoffStrategy;
+    private readonly maxAttemptsProvider;
+    constructor(maxAttempts: number);
+    constructor(maxAttemptsProvider: Provider<number>);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<StandardRetryToken>;
+    refreshRetryTokenForRetry(token: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<StandardRetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+    /**
+     * @returns the current available retry capacity.
+     *
+     * This number decreases when retries are executed and refills when requests or retries succeed.
+     */
+    getCapacity(): number;
+    private getMaxAttempts;
+    private shouldRetry;
+    private getCapacityCost;
+    private isRetryableError;
+}

package/node_modules/@aws-sdk/middleware-user-agent/node_modules/@smithy/util-retry/dist-types/ts3.4/config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @public
+ */
+export declare enum RETRY_MODES {
+    STANDARD = "standard",
+    ADAPTIVE = "adaptive"
+}
+/**
+ * @public
+ *
+ * The default value for how many HTTP requests an SDK should make for a
+ * single SDK operation invocation before giving up
+ */
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * @public
+ *
+ * The default retry algorithm to use.
+ */
+export declare const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;