@cdklabs/cdk-ssm-documents 0.0.56 → 0.0.58

package/node_modules/@smithy/util-middleware/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-middleware",
-  "version": "4.2.13",
+  "version": "4.2.14",
   "description": "Shared utilities for to be used in middleware packages.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -27,7 +27,7 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/types": "^4.14.0",
+    "@smithy/types": "^4.14.1",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

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

@@ -187,6 +187,11 @@ class DefaultRetryToken {
     }
 }
 
+const refusal = {
+    incompatible: 1,
+    attempts: 2,
+    capacity: 3,
+};
 class StandardRetryStrategy {
     mode = exports.RETRY_MODES.STANDARD;
     capacity = INITIAL_RETRY_TOKENS;
@@ -214,8 +219,10 @@ class StandardRetryStrategy {
     }
     async refreshRetryTokenForRetry(token, errorInfo) {
         const maxAttempts = await this.getMaxAttempts();
-        const shouldRetry = this.shouldRetry(token, errorInfo, maxAttempts);
-        if (shouldRetry || token.isLongPoll?.()) {
+        const retryCode = this.retryCode(token, errorInfo, maxAttempts);
+        const shouldRetry = retryCode === 0;
+        const isLongPoll = token.isLongPoll?.();
+        if (shouldRetry || isLongPoll) {
             const errorType = errorInfo.errorType;
             this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
             const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
@@ -224,7 +231,9 @@ class StandardRetryStrategy {
                 retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5_000));
             }
             if (!shouldRetry) {
-                throw Object.assign(new Error("No retry token available"), { $backoff: Retry.v2026 ? retryDelay : 0 });
+                throw Object.assign(new Error("No retry token available"), {
+                    $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
+                });
             }
             else {
                 const capacityCost = this.getCapacityCost(errorType);
@@ -240,6 +249,9 @@ class StandardRetryStrategy {
     getCapacity() {
         return this.capacity;
     }
+    async maxAttempts() {
+        return this.maxAttemptsProvider();
+    }
     async getMaxAttempts() {
         try {
             return await this.maxAttemptsProvider();
@@ -249,11 +261,12 @@ class StandardRetryStrategy {
             return DEFAULT_MAX_ATTEMPTS;
         }
     }
-    shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
+    retryCode(tokenToRenew, errorInfo, maxAttempts) {
         const attempts = tokenToRenew.getRetryCount() + 1;
-        return (attempts < maxAttempts &&
-            this.capacity >= this.getCapacityCost(errorInfo.errorType) &&
-            this.isRetryableError(errorInfo.errorType));
+        const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
+        const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
+        const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
+        return retryableStatus || attemptStatus || capacityStatus;
     }
     getCapacityCost(errorType) {
         return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
@@ -261,9 +274,6 @@ class StandardRetryStrategy {
     isRetryableError(errorType) {
         return errorType === "THROTTLING" || errorType === "TRANSIENT";
     }
-    async maxAttempts() {
-        return this.maxAttemptsProvider();
-    }
 }
 
 class AdaptiveRetryStrategy {

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

@@ -3,6 +3,11 @@ import { INITIAL_RETRY_TOKENS, NO_RETRY_INCREMENT } from "./constants";
 import { DefaultRetryBackoffStrategy } from "./DefaultRetryBackoffStrategy";
 import { DefaultRetryToken } from "./DefaultRetryToken";
 import { Retry } from "./retries-2026-config";
+const refusal = {
+    incompatible: 1,
+    attempts: 2,
+    capacity: 3,
+};
 export class StandardRetryStrategy {
     mode = RETRY_MODES.STANDARD;
     capacity = INITIAL_RETRY_TOKENS;
@@ -30,8 +35,10 @@ export class StandardRetryStrategy {
     }
     async refreshRetryTokenForRetry(token, errorInfo) {
         const maxAttempts = await this.getMaxAttempts();
-        const shouldRetry = this.shouldRetry(token, errorInfo, maxAttempts);
-        if (shouldRetry || token.isLongPoll?.()) {
+        const retryCode = this.retryCode(token, errorInfo, maxAttempts);
+        const shouldRetry = retryCode === 0;
+        const isLongPoll = token.isLongPoll?.();
+        if (shouldRetry || isLongPoll) {
             const errorType = errorInfo.errorType;
             this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
             const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
@@ -40,7 +47,9 @@ export class StandardRetryStrategy {
                 retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5_000));
             }
             if (!shouldRetry) {
-                throw Object.assign(new Error("No retry token available"), { $backoff: Retry.v2026 ? retryDelay : 0 });
+                throw Object.assign(new Error("No retry token available"), {
+                    $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
+                });
             }
             else {
                 const capacityCost = this.getCapacityCost(errorType);
@@ -56,6 +65,9 @@ export class StandardRetryStrategy {
     getCapacity() {
         return this.capacity;
     }
+    async maxAttempts() {
+        return this.maxAttemptsProvider();
+    }
     async getMaxAttempts() {
         try {
             return await this.maxAttemptsProvider();
@@ -65,11 +77,12 @@ export class StandardRetryStrategy {
             return DEFAULT_MAX_ATTEMPTS;
         }
     }
-    shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
+    retryCode(tokenToRenew, errorInfo, maxAttempts) {
         const attempts = tokenToRenew.getRetryCount() + 1;
-        return (attempts < maxAttempts &&
-            this.capacity >= this.getCapacityCost(errorInfo.errorType) &&
-            this.isRetryableError(errorInfo.errorType));
+        const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
+        const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
+        const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
+        return retryableStatus || attemptStatus || capacityStatus;
     }
     getCapacityCost(errorType) {
         return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
@@ -77,7 +90,4 @@ export class StandardRetryStrategy {
     isRetryableError(errorType) {
         return errorType === "THROTTLING" || errorType === "TRANSIENT";
     }
-    async maxAttempts() {
-        return this.maxAttemptsProvider();
-    }
 }

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

@@ -36,13 +36,21 @@ export declare class StandardRetryStrategy implements RetryStrategyV2 {
      * @returns the current available retry capacity.
      */
     getCapacity(): number;
-    private getMaxAttempts;
-    private shouldRetry;
-    private getCapacityCost;
-    private isRetryableError;
     /**
      * There is an existing integration which accesses this field.
      * @deprecated
      */
     maxAttempts(): Promise<number>;
+    private getMaxAttempts;
+    /**
+     * 0 - OK to retry.
+     * 1 - error is not classified as retryable.
+     * 2 - attempt count exhausted.
+     * 3 - no capacity left (retry tokens exhausted).
+     *
+     * @returns 0 or the number of the highest priority (lowest integer) reason why retry is not possible.
+     */
+    private retryCode;
+    private getCapacityCost;
+    private isRetryableError;
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-retry",
-  "version": "4.3.1",
+  "version": "4.3.5",
   "description": "Shared retry utilities to be used in middleware packages.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -30,8 +30,8 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/service-error-classification": "^4.2.13",
-    "@smithy/types": "^4.14.0",
+    "@smithy/service-error-classification": "^4.3.1",
+    "@smithy/types": "^4.14.1",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/util-stream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-stream",
-  "version": "4.5.22",
+  "version": "4.5.25",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline util-stream",
@@ -28,9 +28,9 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/fetch-http-handler": "^5.3.16",
-    "@smithy/node-http-handler": "^4.5.2",
-    "@smithy/types": "^4.14.0",
+    "@smithy/fetch-http-handler": "^5.3.17",
+    "@smithy/node-http-handler": "^4.6.1",
+    "@smithy/types": "^4.14.1",
     "@smithy/util-base64": "^4.3.2",
     "@smithy/util-buffer-from": "^4.2.2",
     "@smithy/util-hex-encoding": "^4.2.2",

package/node_modules/@smithy/util-waiter/dist-cjs/index.js

@@ -52,39 +52,27 @@ const checkExceptions = (result) => {
     return result;
 };
 
-const exponentialBackoffWithJitter = (minDelay, maxDelay, attemptCeiling, attempt) => {
-    if (attempt > attemptCeiling)
-        return maxDelay;
-    const delay = minDelay * 2 ** (attempt - 1);
-    return randomInRange(minDelay, delay);
-};
-const randomInRange = (min, max) => min + Math.random() * (max - min);
 const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
     const observedResponses = {};
-    const { state, reason } = await acceptorChecks(client, input);
-    if (reason) {
-        const message = createMessageFromResponse(reason);
-        observedResponses[message] |= 0;
-        observedResponses[message] += 1;
-    }
-    if (state !== exports.WaiterState.RETRY) {
-        return { state, reason, observedResponses };
-    }
-    let currentAttempt = 1;
+    const [minDelayMs, maxDelayMs] = [minDelay * 1000, maxDelay * 1000];
+    let currentAttempt = 0;
     const waitUntil = Date.now() + maxWaitTime * 1000;
-    const attemptCeiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1;
+    const warn403Time = Date.now() + 60_000;
+    let didWarn403 = false;
     while (true) {
-        if (abortController?.signal?.aborted || abortSignal?.aborted) {
-            const message = "AbortController signal aborted.";
-            observedResponses[message] |= 0;
-            observedResponses[message] += 1;
-            return { state: exports.WaiterState.ABORTED, observedResponses };
-        }
-        const delay = exponentialBackoffWithJitter(minDelay, maxDelay, attemptCeiling, currentAttempt);
-        if (Date.now() + delay * 1000 > waitUntil) {
-            return { state: exports.WaiterState.TIMEOUT, observedResponses };
+        if (currentAttempt > 0) {
+            const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
+            if (abortController?.signal?.aborted || abortSignal?.aborted) {
+                const message = "AbortController signal aborted.";
+                observedResponses[message] |= 0;
+                observedResponses[message] += 1;
+                return { state: exports.WaiterState.ABORTED, observedResponses };
+            }
+            if (Date.now() + delayMs > waitUntil) {
+                return { state: exports.WaiterState.TIMEOUT, observedResponses };
+            }
+            await sleep(delayMs / 1_000);
         }
-        await sleep(delay);
         const { state, reason } = await acceptorChecks(client, input);
         if (reason) {
             const message = createMessageFromResponse(reason);
@@ -92,23 +80,60 @@ const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, cl
             observedResponses[message] += 1;
         }
         if (state !== exports.WaiterState.RETRY) {
-            return { state, reason, observedResponses };
+            return { state, reason, final: reason, observedResponses };
         }
         currentAttempt += 1;
+        if (!didWarn403 && Date.now() >= warn403Time) {
+            checkWarn403(observedResponses, client);
+            didWarn403 = true;
+        }
+    }
+};
+const checkWarn403 = (observedResponses = {}, client) => {
+    const orderedErrors = Object.keys(observedResponses);
+    let count403 = 0;
+    for (const response of orderedErrors) {
+        const n = observedResponses[response] | 0;
+        if (response.startsWith("403:")) {
+            count403 += n;
+        }
+    }
+    const clientLogger = client?.config?.logger;
+    const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger")
+        ? clientLogger
+        : console;
+    if (count403 >= 3 || orderedErrors[orderedErrors.length - 1].startsWith("403:")) {
+        warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
     }
 };
 const createMessageFromResponse = (reason) => {
+    const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
     if (reason?.$responseBodyText) {
-        return `Deserialization error for body: ${reason.$responseBodyText}`;
+        return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
     }
-    if (reason?.$metadata?.httpStatusCode) {
-        if (reason.$response || reason.message) {
-            return `${reason.$response?.statusCode ?? reason.$metadata.httpStatusCode ?? "Unknown"}: ${reason.message}`;
+    if (status) {
+        if (reason?.$response || reason?.message) {
+            return `${status ?? "Unknown"}: ${reason?.message}`;
         }
-        return `${reason.$metadata.httpStatusCode}: OK`;
+        return `${status}: OK`;
     }
     return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
 };
+const exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
+    const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
+    if (attempt > attemptCountCeiling) {
+        return maxDelayMs;
+    }
+    const delay = minDelayMs * 2 ** (attempt - 1);
+    const capped = Math.min(delay, maxDelayMs);
+    const waitFor = randomInRange(minDelayMs, capped);
+    if (Date.now() + waitFor > waitUntil) {
+        const timeRemaining = waitUntil - Date.now();
+        return Math.max(0, timeRemaining - 500);
+    }
+    return waitFor;
+};
+const randomInRange = (min, max) => min + Math.random() * (max - min);
 
 const validateWaiterOptions = (options) => {
     if (options.maxWaitTime <= 0) {

package/node_modules/@smithy/util-waiter/dist-es/poller.js

@@ -1,39 +1,27 @@
 import { getCircularReplacer } from "./circularReplacer";
 import { sleep } from "./utils/sleep";
 import { WaiterState } from "./waiter";
-const exponentialBackoffWithJitter = (minDelay, maxDelay, attemptCeiling, attempt) => {
-    if (attempt > attemptCeiling)
-        return maxDelay;
-    const delay = minDelay * 2 ** (attempt - 1);
-    return randomInRange(minDelay, delay);
-};
-const randomInRange = (min, max) => min + Math.random() * (max - min);
 export const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
     const observedResponses = {};
-    const { state, reason } = await acceptorChecks(client, input);
-    if (reason) {
-        const message = createMessageFromResponse(reason);
-        observedResponses[message] |= 0;
-        observedResponses[message] += 1;
-    }
-    if (state !== WaiterState.RETRY) {
-        return { state, reason, observedResponses };
-    }
-    let currentAttempt = 1;
+    const [minDelayMs, maxDelayMs] = [minDelay * 1000, maxDelay * 1000];
+    let currentAttempt = 0;
     const waitUntil = Date.now() + maxWaitTime * 1000;
-    const attemptCeiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1;
+    const warn403Time = Date.now() + 60_000;
+    let didWarn403 = false;
     while (true) {
-        if (abortController?.signal?.aborted || abortSignal?.aborted) {
-            const message = "AbortController signal aborted.";
-            observedResponses[message] |= 0;
-            observedResponses[message] += 1;
-            return { state: WaiterState.ABORTED, observedResponses };
+        if (currentAttempt > 0) {
+            const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
+            if (abortController?.signal?.aborted || abortSignal?.aborted) {
+                const message = "AbortController signal aborted.";
+                observedResponses[message] |= 0;
+                observedResponses[message] += 1;
+                return { state: WaiterState.ABORTED, observedResponses };
+            }
+            if (Date.now() + delayMs > waitUntil) {
+                return { state: WaiterState.TIMEOUT, observedResponses };
+            }
+            await sleep(delayMs / 1_000);
         }
-        const delay = exponentialBackoffWithJitter(minDelay, maxDelay, attemptCeiling, currentAttempt);
-        if (Date.now() + delay * 1000 > waitUntil) {
-            return { state: WaiterState.TIMEOUT, observedResponses };
-        }
-        await sleep(delay);
         const { state, reason } = await acceptorChecks(client, input);
         if (reason) {
             const message = createMessageFromResponse(reason);
@@ -41,20 +29,59 @@ export const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortControl
             observedResponses[message] += 1;
         }
         if (state !== WaiterState.RETRY) {
-            return { state, reason, observedResponses };
+            return { state, reason, final: reason, observedResponses };
         }
         currentAttempt += 1;
+        if (!didWarn403 && Date.now() >= warn403Time) {
+            checkWarn403(observedResponses, client);
+            didWarn403 = true;
+        }
+    }
+};
+const checkWarn403 = (observedResponses = {}, client) => {
+    const orderedErrors = Object.keys(observedResponses);
+    let maxCount = 0;
+    let count403 = 0;
+    for (const response of orderedErrors) {
+        const n = observedResponses[response] | 0;
+        maxCount = Math.max(n, maxCount);
+        if (response.startsWith("403:")) {
+            count403 += n;
+        }
+    }
+    const clientLogger = client?.config?.logger;
+    const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger")
+        ? clientLogger
+        : console;
+    if (count403 >= 3 || orderedErrors[orderedErrors.length - 1].startsWith("403:")) {
+        warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
     }
 };
 const createMessageFromResponse = (reason) => {
+    const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
     if (reason?.$responseBodyText) {
-        return `Deserialization error for body: ${reason.$responseBodyText}`;
+        return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
     }
-    if (reason?.$metadata?.httpStatusCode) {
-        if (reason.$response || reason.message) {
-            return `${reason.$response?.statusCode ?? reason.$metadata.httpStatusCode ?? "Unknown"}: ${reason.message}`;
+    if (status) {
+        if (reason?.$response || reason?.message) {
+            return `${status ?? "Unknown"}: ${reason?.message}`;
         }
-        return `${reason.$metadata.httpStatusCode}: OK`;
+        return `${status}: OK`;
     }
     return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
 };
+const exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
+    const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
+    if (attempt > attemptCountCeiling) {
+        return maxDelayMs;
+    }
+    const delay = minDelayMs * 2 ** (attempt - 1);
+    const capped = Math.min(delay, maxDelayMs);
+    const waitFor = randomInRange(minDelayMs, capped);
+    if (Date.now() + waitFor > waitUntil) {
+        const timeRemaining = waitUntil - Date.now();
+        return Math.max(0, timeRemaining - 500);
+    }
+    return waitFor;
+};
+const randomInRange = (min, max) => min + Math.random() * (max - min);

package/node_modules/@smithy/util-waiter/dist-types/createWaiter.d.ts

@@ -8,4 +8,4 @@ import type { WaiterOptions, WaiterResult } from "./waiter";
  *
  * @internal
  */
-export declare const createWaiter: <Client, Input>(options: WaiterOptions<Client>, input: Input, acceptorChecks: (client: Client, input: Input) => Promise<WaiterResult>) => Promise<WaiterResult>;
+export declare const createWaiter: <Client, Input, Reason = any>(options: WaiterOptions<Client>, input: Input, acceptorChecks: (client: Client, input: Input) => Promise<WaiterResult<Reason>>) => Promise<WaiterResult<Reason>>;

package/node_modules/@smithy/util-waiter/dist-types/poller.d.ts

@@ -2,9 +2,10 @@ import type { WaiterOptions, WaiterResult } from "./waiter";
 /**
  * Function that runs polling as part of waiters. This will make one inital attempt and then
  * subsequent attempts with an increasing delay.
+ *
  * @param params - options passed to the waiter.
  * @param client - AWS SDK Client
  * @param input - client input
  * @param acceptorChecks - function that checks the acceptor states on each poll.
  */
-export declare const runPolling: <Client, Input>({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }: WaiterOptions<Client>, input: Input, acceptorChecks: (client: Client, input: Input) => Promise<WaiterResult>) => Promise<WaiterResult>;
+export declare const runPolling: <Client, Input, Reason = any>({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }: WaiterOptions<Client>, input: Input, acceptorChecks: (client: Client, input: Input) => Promise<WaiterResult<Reason>>) => Promise<WaiterResult<Reason>>;

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

@@ -1,9 +1,5 @@
-import type { WaiterConfiguration as WaiterConfiguration__ } from "@smithy/types";
-/**
- * @internal
- */
-export interface WaiterConfiguration<T> extends WaiterConfiguration__<T> {
-}
+import type { WaiterConfiguration } from "@smithy/types";
+export { WaiterConfiguration };
 /**
  * @internal
  */
@@ -16,7 +12,7 @@ export declare const waiterServiceDefaults: {
  */
 export type WaiterOptions<Client> = WaiterConfiguration<Client> & Required<Pick<WaiterConfiguration<Client>, "minDelay" | "maxDelay">>;
 /**
- * @internal
+ * @public
  */
 export declare enum WaiterState {
     ABORTED = "ABORTED",
@@ -26,14 +22,19 @@ export declare enum WaiterState {
     TIMEOUT = "TIMEOUT"
 }
 /**
- * @internal
+ * @public
  */
-export type WaiterResult = {
+export type WaiterResult<R = any> = {
     state: WaiterState;
     /**
-     * (optional) Indicates a reason for why a waiter has reached its state.
+     * @deprecated because this was untyped as `any`, new code should use the field 'final',
+     * which is the same value, but typed.
      */
     reason?: any;
+    /**
+     * (optional) Indicates a reason for why a waiter has reached its state.
+     */
+    final?: R;
     /**
      * Responses observed by the waiter during its polling, where the value
      * is the count.
@@ -41,9 +42,8 @@ export type WaiterResult = {
     observedResponses?: Record<string, number>;
 };
 /**
- * @internal
- *
  * Handles and throws exceptions resulting from the waiterResult
+ * @internal
  * @param result - WaiterResult
  */
-export declare const checkExceptions: (result: WaiterResult) => WaiterResult;
+export declare const checkExceptions: <R>(result: WaiterResult<R>) => WaiterResult<R>;

package/node_modules/@smithy/util-waiter/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@smithy/util-waiter",
-  "version": "4.2.15",
+  "version": "4.3.0",
   "description": "Shared utilities for client waiters for the AWS SDK",
   "dependencies": {
-    "@smithy/types": "^4.14.0",
+    "@smithy/types": "^4.14.1",
     "tslib": "^2.6.2"
   },
   "scripts": {
@@ -47,7 +47,7 @@
     "directory": "packages/util-waiter"
   },
   "devDependencies": {
-    "@smithy/abort-controller": "^4.2.13",
+    "@smithy/abort-controller": "^4.2.14",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
     "premove": "4.0.0",

package/node_modules/fast-xml-builder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-builder",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Build XML from JSON without C/C++ based libraries",
   "main": "./lib/fxb.cjs",
   "type": "module",

package/node_modules/fast-xml-builder/src/fxb.js

@@ -486,9 +486,13 @@ function buildEmptyObjNode(val, key, attrStr, level) {
 
 Builder.prototype.buildTextValNode = function (val, key, attrStr, level, matcher) {
   if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
-    return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
+    const safeVal = String(val).replace(/\]\]>/g, ']]]]><![CDATA[>');
+    return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;
   } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
-    return this.indentate(level) + `<!--${val}-->` + this.newLine;
+    const safeVal = String(val)
+      .replace(/--/g, '- -')   // -- is illegal anywhere in comment content
+      .replace(/-$/, '- ');    // trailing - would form -- with the closing -->
+    return this.indentate(level) + `<!--${safeVal}-->` + this.newLine;
   } else if (key[0] === "?") {//PI tag
     return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;
   } else {

package/node_modules/fast-xml-builder/src/orderedJs2Xml.js

@@ -82,12 +82,18 @@ function arrToStr(arr, options, indentation, matcher, stopNodeExpressions) {
             if (isPreviousElementTag) {
                 xmlStr += indentation;
             }
-            xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
+            const val = tagObj[tagName][0][options.textNodeName];
+            const safeVal = String(val).replace(/\]\]>/g, ']]]]><![CDATA[>');
+            xmlStr += `<![CDATA[${safeVal}]]>`;
             isPreviousElementTag = false;
             matcher.pop();
             continue;
         } else if (tagName === options.commentPropName) {
-            xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
+            const val = tagObj[tagName][0][options.textNodeName]
+            const safeVal = String(val)
+                .replace(/--/g, '- -')   // -- is illegal anywhere in comment content
+                .replace(/-$/, '- ');    // trailing - would form -- with the closing -->
+            xmlStr += indentation + `<!--${safeVal}-->`;
             isPreviousElementTag = true;
             matcher.pop();
             continue;
@@ -289,4 +295,12 @@ function replaceEntitiesValue(textValue, options) {
         }
     }
     return textValue;
+}
+
+function cdataVal(val) {
+
+}
+
+function commentVal(val) {
+
 }