fix: 修复配额说明重复和undefined问题

- 在editStorageForm中初始化oss_storage_quota_value和oss_quota_unit
- 删除重复的旧配额说明块，保留新的当前配额设置显示

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

backend/node_modules/@smithy/util-retry/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

backend/node_modules/@smithy/util-retry/README.md

@@ -0,0 +1,78 @@
+# @smithy/util-retry
+
+[![NPM version](https://img.shields.io/npm/v/@smithy/util-retry/latest.svg)](https://www.npmjs.com/package/@smithy/util-retry)
+[![NPM downloads](https://img.shields.io/npm/dm/@smithy/util-retry.svg)](https://www.npmjs.com/package/@smithy/util-retry)
+
+This package provides shared utilities for retries.
+
+## Usage
+
+### Default
+
+By default, each client already has a default retry strategy. The default retry count is 3, and
+only retryable errors will be retried.
+
+[AWS Documentation: Retry behavior](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html).
+
+```js
+import { S3Client } from "@aws-sdk/client-s3";
+
+const client = new S3Client({}); // default retry strategy included.
+```
+
+### MaxAttempts
+
+If you want to change the number of attempts, you can provide `maxAttempts` configuration during client creation.
+
+```js
+import { S3Client } from "@aws-sdk/client-s3";
+
+const client = new S3Client({ maxAttempts: 4 });
+```
+
+This is recommended because the `StandardRetryStrategy` includes backoff calculation,
+deciding whether an error should be retried, and a retry token counter.
+
+### MaxAttempts and BackoffComputation
+
+If you want to change the number of attempts and use a custom delay
+computation, you can use the `ConfiguredRetryStrategy` from `@smithy/util-retry`.
+
+```js
+import { S3Client } from "@aws-sdk/client-s3";
+import { ConfiguredRetryStrategy } from "@smithy/util-retry";
+
+const client = new S3Client({
+  retryStrategy: new ConfiguredRetryStrategy(
+    4, // max attempts.
+    (attempt: number) => 100 + attempt * 1000 // backoff function.
+  ),
+});
+```
+
+This example sets the backoff at 100ms plus 1s per attempt.
+
+### MaxAttempts and RetryStrategy
+
+If you provide both `maxAttempts` and `retryStrategy`, the `retryStrategy` will
+get precedence as it's more specific.
+
+```js
+import { S3Client } from "@aws-sdk/client-s3";
+import { ConfiguredRetryStrategy } from "@smithy/util-retry";
+
+const client = new S3Client({
+  maxAttempts: 2, // ignored.
+  retryStrategy: new ConfiguredRetryStrategy(
+    4, // used.
+    (attempt: number) => 100 + attempt * 1000 // backoff function.
+  ),
+});
+```
+
+### Further customization
+
+You can implement the `RetryStrategyV2` interface.
+
+Source: https://github.com/smithy-lang/smithy-typescript/blob/main/packages/types/src/retry.ts
+API Docs: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-smithy-types/Interface/RetryStrategyV2/

backend/node_modules/@smithy/util-retry/dist-cjs/index.js

@@ -0,0 +1,278 @@
+'use strict';
+
+var serviceErrorClassification = require('@smithy/service-error-classification');
+
+exports.RETRY_MODES = void 0;
+(function (RETRY_MODES) {
+    RETRY_MODES["STANDARD"] = "standard";
+    RETRY_MODES["ADAPTIVE"] = "adaptive";
+})(exports.RETRY_MODES || (exports.RETRY_MODES = {}));
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_RETRY_MODE = exports.RETRY_MODES.STANDARD;
+
+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 (serviceErrorClassification.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));
+    }
+}
+
+const DEFAULT_RETRY_DELAY_BASE = 100;
+const MAXIMUM_RETRY_DELAY = 20 * 1000;
+const THROTTLING_RETRY_DELAY_BASE = 500;
+const INITIAL_RETRY_TOKENS = 500;
+const RETRY_COST = 5;
+const TIMEOUT_RETRY_COST = 10;
+const NO_RETRY_INCREMENT = 1;
+const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+const REQUEST_HEADER = "amz-sdk-request";
+
+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,
+    };
+};
+
+const createDefaultRetryToken = ({ retryDelay, retryCount, retryCost, }) => {
+    const getRetryCount = () => retryCount;
+    const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);
+    const getRetryCost = () => retryCost;
+    return {
+        getRetryCount,
+        getRetryDelay,
+        getRetryCost,
+    };
+};
+
+class StandardRetryStrategy {
+    maxAttempts;
+    mode = exports.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";
+    }
+}
+
+class AdaptiveRetryStrategy {
+    maxAttemptsProvider;
+    rateLimiter;
+    standardRetryStrategy;
+    mode = exports.RETRY_MODES.ADAPTIVE;
+    constructor(maxAttemptsProvider, options) {
+        this.maxAttemptsProvider = maxAttemptsProvider;
+        const { rateLimiter } = options ?? {};
+        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+        this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
+    }
+    async acquireInitialRetryToken(retryTokenScope) {
+        await this.rateLimiter.getSendToken();
+        return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+    }
+    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+        this.rateLimiter.updateClientSendingRate(errorInfo);
+        return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+    }
+    recordSuccess(token) {
+        this.rateLimiter.updateClientSendingRate({});
+        this.standardRetryStrategy.recordSuccess(token);
+    }
+}
+
+class ConfiguredRetryStrategy extends StandardRetryStrategy {
+    computeNextBackoffDelay;
+    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;
+    }
+}
+
+exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy;
+exports.ConfiguredRetryStrategy = ConfiguredRetryStrategy;
+exports.DEFAULT_MAX_ATTEMPTS = DEFAULT_MAX_ATTEMPTS;
+exports.DEFAULT_RETRY_DELAY_BASE = DEFAULT_RETRY_DELAY_BASE;
+exports.DEFAULT_RETRY_MODE = DEFAULT_RETRY_MODE;
+exports.DefaultRateLimiter = DefaultRateLimiter;
+exports.INITIAL_RETRY_TOKENS = INITIAL_RETRY_TOKENS;
+exports.INVOCATION_ID_HEADER = INVOCATION_ID_HEADER;
+exports.MAXIMUM_RETRY_DELAY = MAXIMUM_RETRY_DELAY;
+exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT;
+exports.REQUEST_HEADER = REQUEST_HEADER;
+exports.RETRY_COST = RETRY_COST;
+exports.StandardRetryStrategy = StandardRetryStrategy;
+exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE;
+exports.TIMEOUT_RETRY_COST = TIMEOUT_RETRY_COST;

backend/node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js

@@ -0,0 +1,27 @@
+import { RETRY_MODES } from "./config";
+import { DefaultRateLimiter } from "./DefaultRateLimiter";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+export class AdaptiveRetryStrategy {
+    maxAttemptsProvider;
+    rateLimiter;
+    standardRetryStrategy;
+    mode = RETRY_MODES.ADAPTIVE;
+    constructor(maxAttemptsProvider, options) {
+        this.maxAttemptsProvider = maxAttemptsProvider;
+        const { rateLimiter } = options ?? {};
+        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+        this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
+    }
+    async acquireInitialRetryToken(retryTokenScope) {
+        await this.rateLimiter.getSendToken();
+        return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+    }
+    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+        this.rateLimiter.updateClientSendingRate(errorInfo);
+        return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+    }
+    recordSuccess(token) {
+        this.rateLimiter.updateClientSendingRate({});
+        this.standardRetryStrategy.recordSuccess(token);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { DEFAULT_RETRY_DELAY_BASE } from "./constants";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+export class ConfiguredRetryStrategy extends StandardRetryStrategy {
+    computeNextBackoffDelay;
+    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;
+    }
+}

backend/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));
+    }
+}

backend/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";
+    }
+}

backend/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;

backend/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";

backend/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,
+    };
+};

backend/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,
+    };
+};

backend/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";

backend/node_modules/@smithy/util-retry/dist-es/types.js

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

backend/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;
+}

backend/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>;
+}

backend/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;
+}

backend/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;
+}

backend/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;

backend/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";

backend/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;

backend/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;

backend/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";

backend/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;
+}

backend/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>;
+}

backend/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;
+}

backend/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;
+}

backend/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;

backend/node_modules/@smithy/util-retry/dist-types/ts3.4/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";

backend/node_modules/@smithy/util-retry/dist-types/ts3.4/defaultRetryBackoffStrategy.d.ts

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

backend/node_modules/@smithy/util-retry/dist-types/ts3.4/defaultRetryToken.d.ts

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

backend/node_modules/@smithy/util-retry/dist-types/ts3.4/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";

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

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

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

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

backend/node_modules/@smithy/util-retry/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@smithy/util-retry",
+  "version": "4.2.8",
+  "description": "Shared retry utilities to be used in middleware packages.",
+  "main": "./dist-cjs/index.js",
+  "module": "./dist-es/index.js",
+  "scripts": {
+    "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
+    "build:cjs": "node ../../scripts/inline util-retry",
+    "build:es": "yarn g:tsc -p tsconfig.es.json",
+    "build:types": "yarn g:tsc -p tsconfig.types.json",
+    "build:types:downlevel": "rimraf dist-types/ts3.4 && downlevel-dts dist-types dist-types/ts3.4",
+    "stage-release": "rimraf ./.release && yarn pack && mkdir ./.release && tar zxvf ./package.tgz --directory ./.release && rm ./package.tgz",
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo || exit 0",
+    "lint": "eslint -c ../../.eslintrc.js \"src/**/*.ts\"",
+    "format": "prettier --config ../../prettier.config.js --ignore-path ../../.prettierignore --write \"**/*.{ts,md,json}\"",
+    "extract:docs": "api-extractor run --local",
+    "test": "yarn g:vitest run",
+    "test:watch": "yarn g:vitest watch",
+    "test:integration": "yarn g:vitest run -c vitest.config.integ.mts",
+    "test:integration:watch": "yarn g:vitest watch -c vitest.config.integ.mts"
+  },
+  "keywords": [
+    "aws",
+    "retry"
+  ],
+  "author": {
+    "name": "AWS SDK for JavaScript Team",
+    "url": "https://aws.amazon.com/javascript/"
+  },
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "dependencies": {
+    "@smithy/service-error-classification": "^4.2.8",
+    "@smithy/types": "^4.12.0",
+    "tslib": "^2.6.2"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "concurrently": "7.0.0",
+    "downlevel-dts": "0.10.1",
+    "rimraf": "5.0.10",
+    "typedoc": "0.23.23"
+  },
+  "types": "./dist-types/index.d.ts",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "typesVersions": {
+    "<4.0": {
+      "types/*": [
+        "types/ts3.4/*"
+      ]
+    }
+  },
+  "files": [
+    "dist-*/**"
+  ],
+  "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/master/packages/util-retry",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/smithy-lang/smithy-typescript.git",
+    "directory": "packages/util-retry"
+  },
+  "typedoc": {
+    "entryPoint": "src/index.ts"
+  },
+  "publishConfig": {
+    "directory": ".release/package"
+  }
+}