@aws/lsp-codewhisperer 0.0.17 → 0.0.18

package/node_modules/@smithy/util-retry/dist-es/ConfiguredRetryStrategy.js

@@ -1,18 +0,0 @@
-import { DEFAULT_RETRY_DELAY_BASE } from "./constants";
-import { StandardRetryStrategy } from "./StandardRetryStrategy";
-export class ConfiguredRetryStrategy extends StandardRetryStrategy {
-    constructor(maxAttempts, computeNextBackoffDelay = DEFAULT_RETRY_DELAY_BASE) {
-        super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts);
-        if (typeof computeNextBackoffDelay === "number") {
-            this.computeNextBackoffDelay = () => computeNextBackoffDelay;
-        }
-        else {
-            this.computeNextBackoffDelay = computeNextBackoffDelay;
-        }
-    }
-    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
-        const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
-        token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
-        return token;
-    }
-}

package/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js

@@ -1,99 +0,0 @@
-import { isThrottlingError } from "@smithy/service-error-classification";
-export class DefaultRateLimiter {
-    constructor(options) {
-        this.currentCapacity = 0;
-        this.enabled = false;
-        this.lastMaxRate = 0;
-        this.measuredTxRate = 0;
-        this.requestCount = 0;
-        this.lastTimestamp = 0;
-        this.timeWindow = 0;
-        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) => setTimeout(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/@smithy/util-retry/dist-es/StandardRetryStrategy.js

@@ -1,65 +0,0 @@
-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 {
-    constructor(maxAttempts) {
-        this.maxAttempts = maxAttempts;
-        this.mode = RETRY_MODES.STANDARD;
-        this.capacity = INITIAL_RETRY_TOKENS;
-        this.retryBackoffStrategy = getDefaultRetryBackoffStrategy();
-        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/@smithy/util-retry/dist-es/config.js

@@ -1,7 +0,0 @@
-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/@smithy/util-retry/dist-es/constants.js

@@ -1,9 +0,0 @@
-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/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js

@@ -1,14 +0,0 @@
-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/@smithy/util-retry/dist-es/defaultRetryToken.js

@@ -1,11 +0,0 @@
-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/@smithy/util-retry/dist-es/index.js

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

package/node_modules/@smithy/util-retry/dist-types/AdaptiveRetryStrategy.d.ts

@@ -1,33 +0,0 @@
-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/@smithy/util-retry/dist-types/ConfiguredRetryStrategy.d.ts

@@ -1,32 +0,0 @@
-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/@smithy/util-retry/dist-types/DefaultRateLimiter.d.ts

@@ -1,45 +0,0 @@
-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 {
-    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/@smithy/util-retry/dist-types/StandardRetryStrategy.d.ts

@@ -1,26 +0,0 @@
-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/@smithy/util-retry/dist-types/config.d.ts

@@ -1,20 +0,0 @@
-/**
- * @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/@smithy/util-retry/dist-types/constants.d.ts

@@ -1,59 +0,0 @@
-/**
- * @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/@smithy/util-retry/dist-types/defaultRetryBackoffStrategy.d.ts

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

package/node_modules/@smithy/util-retry/dist-types/defaultRetryToken.d.ts

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

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

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

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

@@ -1,33 +0,0 @@
-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/@smithy/util-retry/dist-types/ts3.4/ConfiguredRetryStrategy.d.ts

@@ -1,32 +0,0 @@
-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/@smithy/util-retry/dist-types/ts3.4/DefaultRateLimiter.d.ts

@@ -1,45 +0,0 @@
-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 {
-    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/@smithy/util-retry/dist-types/ts3.4/StandardRetryStrategy.d.ts

@@ -1,26 +0,0 @@
-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/@smithy/util-retry/dist-types/ts3.4/config.d.ts

@@ -1,20 +0,0 @@
-/**
- * @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;