@cdklabs/cdk-ecs-codedeploy 0.0.102 → 0.0.103

package/node_modules/@aws-sdk/node-http-handler/dist-cjs/node-http2-handler.js

@@ -5,10 +5,12 @@ const protocol_http_1 = require("@aws-sdk/protocol-http");
 const querystring_builder_1 = require("@aws-sdk/querystring-builder");
 const http2_1 = require("http2");
 const get_transformed_headers_1 = require("./get-transformed-headers");
+const node_http2_connection_manager_1 = require("./node-http2-connection-manager");
 const write_request_body_1 = require("./write-request-body");
 class NodeHttp2Handler {
     constructor(options) {
         this.metadata = { handlerProtocol: "h2" };
+        this.connectionManager = new node_http2_connection_manager_1.NodeHttp2ConnectionManager({});
         this.configProvider = new Promise((resolve, reject) => {
             if (typeof options === "function") {
                 options()
@@ -21,20 +23,21 @@ class NodeHttp2Handler {
                 resolve(options || {});
             }
         });
-        this.sessionCache = new Map();
     }
     destroy() {
-        for (const sessions of this.sessionCache.values()) {
-            sessions.forEach((session) => this.destroySession(session));
-        }
-        this.sessionCache.clear();
+        this.connectionManager.destroy();
     }
     async handle(request, { abortSignal } = {}) {
         if (!this.config) {
             this.config = await this.configProvider;
+            this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);
+            if (this.config.maxConcurrentStreams) {
+                this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams);
+            }
         }
         const { requestTimeout, disableConcurrentStreams } = this.config;
         return new Promise((resolve, rejectOriginal) => {
+            var _a;
             let fulfilled = false;
             if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
                 fulfilled = true;
@@ -45,7 +48,11 @@ class NodeHttp2Handler {
             }
             const { hostname, method, port, protocol, path, query } = request;
             const authority = `${protocol}//${hostname}${port ? `:${port}` : ""}`;
-            const session = this.getSession(authority, disableConcurrentStreams || false);
+            const requestContext = { destination: new URL(authority) };
+            const session = this.connectionManager.lease(requestContext, {
+                requestTimeout: (_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionTimeout,
+                disableConcurrentStreams: disableConcurrentStreams || false,
+            });
             const reject = (err) => {
                 if (disableConcurrentStreams) {
                     this.destroySession(session);
@@ -70,7 +77,7 @@ class NodeHttp2Handler {
                 resolve({ response: httpResponse });
                 if (disableConcurrentStreams) {
                     session.close();
-                    this.deleteSessionFromCache(authority, session);
+                    this.connectionManager.deleteSession(authority, session);
                 }
             });
             if (requestTimeout) {
@@ -108,40 +115,10 @@ class NodeHttp2Handler {
             (0, write_request_body_1.writeRequestBody)(req, request);
         });
     }
-    getSession(authority, disableConcurrentStreams) {
-        var _a;
-        const sessionCache = this.sessionCache;
-        const existingSessions = sessionCache.get(authority) || [];
-        if (existingSessions.length > 0 && !disableConcurrentStreams)
-            return existingSessions[0];
-        const newSession = (0, http2_1.connect)(authority);
-        newSession.unref();
-        const destroySessionCb = () => {
-            this.destroySession(newSession);
-            this.deleteSessionFromCache(authority, newSession);
-        };
-        newSession.on("goaway", destroySessionCb);
-        newSession.on("error", destroySessionCb);
-        newSession.on("frameError", destroySessionCb);
-        newSession.on("close", () => this.deleteSessionFromCache(authority, newSession));
-        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionTimeout) {
-            newSession.setTimeout(this.config.sessionTimeout, destroySessionCb);
-        }
-        existingSessions.push(newSession);
-        sessionCache.set(authority, existingSessions);
-        return newSession;
-    }
     destroySession(session) {
         if (!session.destroyed) {
             session.destroy();
         }
     }
-    deleteSessionFromCache(authority, session) {
-        const existingSessions = this.sessionCache.get(authority) || [];
-        if (!existingSessions.includes(session)) {
-            return;
-        }
-        this.sessionCache.set(authority, existingSessions.filter((s) => s !== session));
-    }
 }
 exports.NodeHttp2Handler = NodeHttp2Handler;

package/node_modules/@aws-sdk/node-http-handler/dist-es/node-http-handler.js

@@ -4,9 +4,8 @@ import { Agent as hAgent, request as hRequest } from "http";
 import { Agent as hsAgent, request as hsRequest } from "https";
 import { NODEJS_TIMEOUT_ERROR_CODES } from "./constants";
 import { getTransformedHeaders } from "./get-transformed-headers";
-import { setConnectionTimeout } from "./set-connection-timeout";
-import { setSocketTimeout } from "./set-socket-timeout";
 import { writeRequestBody } from "./write-request-body";
+export const DEFAULT_REQUEST_TIMEOUT = 0;
 export class NodeHttpHandler {
     constructor(options) {
         this.metadata = { handlerProtocol: "http/1.1" };
@@ -24,12 +23,13 @@ export class NodeHttpHandler {
         });
     }
     resolveDefaultConfig(options) {
-        const { connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {};
+        const { requestTimeout, connectionTimeout, socketTimeout, httpAgent, httpsAgent } = options || {};
         const keepAlive = true;
         const maxSockets = 50;
         return {
             connectionTimeout,
             socketTimeout,
+            requestTimeout: requestTimeout ?? connectionTimeout ?? socketTimeout ?? DEFAULT_REQUEST_TIMEOUT,
             httpAgent: httpAgent || new hAgent({ keepAlive, maxSockets }),
             httpsAgent: httpsAgent || new hsAgent({ keepAlive, maxSockets }),
         };
@@ -79,8 +79,11 @@ export class NodeHttpHandler {
                     reject(err);
                 }
             });
-            setConnectionTimeout(req, reject, this.config.connectionTimeout);
-            setSocketTimeout(req, reject, this.config.socketTimeout);
+            const timeout = this.config?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+            req.setTimeout(timeout, () => {
+                req.destroy();
+                reject(Object.assign(new Error(`Connection timed out after ${timeout} ms`), { name: "TimeoutError" }));
+            });
             if (abortSignal) {
                 abortSignal.onabort = () => {
                     req.abort();

package/node_modules/@aws-sdk/node-http-handler/dist-es/node-http2-connection-manager.js

@@ -0,0 +1,86 @@
+import http2 from "http2";
+import { NodeHttp2ConnectionPool } from "./node-http2-connection-pool";
+export class NodeHttp2ConnectionManager {
+    constructor(config) {
+        this.sessionCache = new Map();
+        this.config = config;
+        if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
+            throw new RangeError("maxConcurrency must be greater than zero.");
+        }
+    }
+    lease(requestContext, connectionConfiguration) {
+        const url = this.getUrlString(requestContext);
+        const existingPool = this.sessionCache.get(url);
+        if (existingPool) {
+            const existingSession = existingPool.poll();
+            if (existingSession && !this.config.disableConcurrency) {
+                return existingSession;
+            }
+        }
+        const session = http2.connect(url);
+        if (this.config.maxConcurrency) {
+            session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
+                if (err) {
+                    throw new Error("Fail to set maxConcurrentStreams to " +
+                        this.config.maxConcurrency +
+                        "when creating new session for " +
+                        requestContext.destination.toString());
+                }
+            });
+        }
+        session.unref();
+        const destroySessionCb = () => {
+            session.destroy();
+            this.deleteSession(url, session);
+        };
+        session.on("goaway", destroySessionCb);
+        session.on("error", destroySessionCb);
+        session.on("frameError", destroySessionCb);
+        session.on("close", () => this.deleteSession(url, session));
+        if (connectionConfiguration.requestTimeout) {
+            session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb);
+        }
+        const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool();
+        connectionPool.offerLast(session);
+        this.sessionCache.set(url, connectionPool);
+        return session;
+    }
+    deleteSession(authority, session) {
+        const existingConnectionPool = this.sessionCache.get(authority);
+        if (!existingConnectionPool) {
+            return;
+        }
+        if (!existingConnectionPool.contains(session)) {
+            return;
+        }
+        existingConnectionPool.remove(session);
+        this.sessionCache.set(authority, existingConnectionPool);
+    }
+    release(requestContext, session) {
+        const cacheKey = this.getUrlString(requestContext);
+        this.sessionCache.get(cacheKey)?.offerLast(session);
+    }
+    destroy() {
+        for (const [key, connectionPool] of this.sessionCache) {
+            for (const session of connectionPool) {
+                if (!session.destroyed) {
+                    session.destroy();
+                }
+                connectionPool.remove(session);
+            }
+            this.sessionCache.delete(key);
+        }
+    }
+    setMaxConcurrentStreams(maxConcurrentStreams) {
+        if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
+            throw new RangeError("maxConcurrentStreams must be greater than zero.");
+        }
+        this.config.maxConcurrency = maxConcurrentStreams;
+    }
+    setDisableConcurrentStreams(disableConcurrentStreams) {
+        this.config.disableConcurrency = disableConcurrentStreams;
+    }
+    getUrlString(request) {
+        return request.destination.toString();
+    }
+}

package/node_modules/@aws-sdk/node-http-handler/dist-es/node-http2-connection-pool.js

@@ -0,0 +1,32 @@
+export class NodeHttp2ConnectionPool {
+    constructor(sessions) {
+        this.sessions = [];
+        this.sessions = sessions ?? [];
+    }
+    poll() {
+        if (this.sessions.length > 0) {
+            return this.sessions.shift();
+        }
+    }
+    offerLast(session) {
+        this.sessions.push(session);
+    }
+    contains(session) {
+        return this.sessions.includes(session);
+    }
+    remove(session) {
+        this.sessions = this.sessions.filter((s) => s !== session);
+    }
+    [Symbol.iterator]() {
+        return this.sessions[Symbol.iterator]();
+    }
+    destroy(connection) {
+        for (const session of this.sessions) {
+            if (session === connection) {
+                if (!session.destroyed) {
+                    session.destroy();
+                }
+            }
+        }
+    }
+}

package/node_modules/@aws-sdk/node-http-handler/dist-es/node-http2-handler.js

@@ -1,11 +1,13 @@
 import { HttpResponse } from "@aws-sdk/protocol-http";
 import { buildQueryString } from "@aws-sdk/querystring-builder";
-import { connect, constants } from "http2";
+import { constants } from "http2";
 import { getTransformedHeaders } from "./get-transformed-headers";
+import { NodeHttp2ConnectionManager } from "./node-http2-connection-manager";
 import { writeRequestBody } from "./write-request-body";
 export class NodeHttp2Handler {
     constructor(options) {
         this.metadata = { handlerProtocol: "h2" };
+        this.connectionManager = new NodeHttp2ConnectionManager({});
         this.configProvider = new Promise((resolve, reject) => {
             if (typeof options === "function") {
                 options()
@@ -18,17 +20,17 @@ export class NodeHttp2Handler {
                 resolve(options || {});
             }
         });
-        this.sessionCache = new Map();
     }
     destroy() {
-        for (const sessions of this.sessionCache.values()) {
-            sessions.forEach((session) => this.destroySession(session));
-        }
-        this.sessionCache.clear();
+        this.connectionManager.destroy();
     }
     async handle(request, { abortSignal } = {}) {
         if (!this.config) {
             this.config = await this.configProvider;
+            this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false);
+            if (this.config.maxConcurrentStreams) {
+                this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams);
+            }
         }
         const { requestTimeout, disableConcurrentStreams } = this.config;
         return new Promise((resolve, rejectOriginal) => {
@@ -42,7 +44,11 @@ export class NodeHttp2Handler {
             }
             const { hostname, method, port, protocol, path, query } = request;
             const authority = `${protocol}//${hostname}${port ? `:${port}` : ""}`;
-            const session = this.getSession(authority, disableConcurrentStreams || false);
+            const requestContext = { destination: new URL(authority) };
+            const session = this.connectionManager.lease(requestContext, {
+                requestTimeout: this.config?.sessionTimeout,
+                disableConcurrentStreams: disableConcurrentStreams || false,
+            });
             const reject = (err) => {
                 if (disableConcurrentStreams) {
                     this.destroySession(session);
@@ -67,7 +73,7 @@ export class NodeHttp2Handler {
                 resolve({ response: httpResponse });
                 if (disableConcurrentStreams) {
                     session.close();
-                    this.deleteSessionFromCache(authority, session);
+                    this.connectionManager.deleteSession(authority, session);
                 }
             });
             if (requestTimeout) {
@@ -105,38 +111,9 @@ export class NodeHttp2Handler {
             writeRequestBody(req, request);
         });
     }
-    getSession(authority, disableConcurrentStreams) {
-        const sessionCache = this.sessionCache;
-        const existingSessions = sessionCache.get(authority) || [];
-        if (existingSessions.length > 0 && !disableConcurrentStreams)
-            return existingSessions[0];
-        const newSession = connect(authority);
-        newSession.unref();
-        const destroySessionCb = () => {
-            this.destroySession(newSession);
-            this.deleteSessionFromCache(authority, newSession);
-        };
-        newSession.on("goaway", destroySessionCb);
-        newSession.on("error", destroySessionCb);
-        newSession.on("frameError", destroySessionCb);
-        newSession.on("close", () => this.deleteSessionFromCache(authority, newSession));
-        if (this.config?.sessionTimeout) {
-            newSession.setTimeout(this.config.sessionTimeout, destroySessionCb);
-        }
-        existingSessions.push(newSession);
-        sessionCache.set(authority, existingSessions);
-        return newSession;
-    }
     destroySession(session) {
         if (!session.destroyed) {
             session.destroy();
         }
     }
-    deleteSessionFromCache(authority, session) {
-        const existingSessions = this.sessionCache.get(authority) || [];
-        if (!existingSessions.includes(session)) {
-            return;
-        }
-        this.sessionCache.set(authority, existingSessions.filter((s) => s !== session));
-    }
 }

package/node_modules/@aws-sdk/node-http-handler/dist-types/node-http-handler.d.ts

@@ -9,11 +9,26 @@ import { Agent as hsAgent } from "https";
  */
 export interface NodeHttpHandlerOptions {
     /**
+     * @deprecated Use {@link requestTimeout}
+     *
+     * Note:{@link NodeHttpHandler} will resolve request timeout via nullish coalescing the following fields:
+     * {@link requestTimeout} ?? {@link connectionTimeout} ?? {@link socketTimeout} ?? {@link DEFAULT_REQUEST_TIMEOUT}
+     *
      * The maximum time in milliseconds that the connection phase of a request
      * may take before the connection attempt is abandoned.
      */
     connectionTimeout?: number;
     /**
+     * The maximum time in milliseconds that the connection phase of a request
+     * may take before the connection attempt is abandoned.
+     */
+    requestTimeout?: number;
+    /**
+     * @deprecated Use {@link requestTimeout}
+     *
+     * Note:{@link NodeHttpHandler} will resolve request timeout via nullish coalescing the following fields:
+     * {@link requestTimeout} ?? {@link connectionTimeout} ?? {@link socketTimeout} ?? {@link DEFAULT_REQUEST_TIMEOUT}
+     *
      * The maximum time in milliseconds that a socket may remain idle before it
      * is closed.
      */
@@ -21,6 +36,7 @@ export interface NodeHttpHandlerOptions {
     httpAgent?: hAgent;
     httpsAgent?: hsAgent;
 }
+export declare const DEFAULT_REQUEST_TIMEOUT = 0;
 export declare class NodeHttpHandler implements HttpHandler {
     private config?;
     private readonly configProvider;

package/node_modules/@aws-sdk/node-http-handler/dist-types/node-http2-connection-manager.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { RequestContext } from "@aws-sdk/types";
+import { ConnectConfiguration } from "@aws-sdk/types/src/connection/config";
+import { ConnectionManager, ConnectionManagerConfiguration } from "@aws-sdk/types/src/connection/manager";
+import { ClientHttp2Session } from "http2";
+export declare class NodeHttp2ConnectionManager implements ConnectionManager<ClientHttp2Session> {
+    constructor(config: ConnectionManagerConfiguration);
+    private config;
+    private readonly sessionCache;
+    lease(requestContext: RequestContext, connectionConfiguration: ConnectConfiguration): ClientHttp2Session;
+    /**
+     * Delete a session from the connection pool.
+     * @param authority The authority of the session to delete.
+     * @param session The session to delete.
+     */
+    deleteSession(authority: string, session: ClientHttp2Session): void;
+    release(requestContext: RequestContext, session: ClientHttp2Session): void;
+    destroy(): void;
+    setMaxConcurrentStreams(maxConcurrentStreams: number): void;
+    setDisableConcurrentStreams(disableConcurrentStreams: boolean): void;
+    private getUrlString;
+}

package/node_modules/@aws-sdk/node-http-handler/dist-types/node-http2-connection-pool.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { ConnectionPool } from "@aws-sdk/types/src/connection/pool";
+import { ClientHttp2Session } from "http2";
+export declare class NodeHttp2ConnectionPool implements ConnectionPool<ClientHttp2Session> {
+    private sessions;
+    constructor(sessions?: ClientHttp2Session[]);
+    poll(): ClientHttp2Session | void;
+    offerLast(session: ClientHttp2Session): void;
+    contains(session: ClientHttp2Session): boolean;
+    remove(session: ClientHttp2Session): void;
+    [Symbol.iterator](): IterableIterator<ClientHttp2Session>;
+    destroy(connection: ClientHttp2Session): void;
+}

package/node_modules/@aws-sdk/node-http-handler/dist-types/node-http2-handler.d.ts

@@ -17,11 +17,18 @@ export interface NodeHttp2HandlerOptions {
     sessionTimeout?: number;
     /**
      * Disables processing concurrent streams on a ClientHttp2Session instance. When set
-     * to true, the handler will create a new session instance for each request to a URL.
+     * to true, a new session instance is created for each request to a URL.
      * **Default:** false.
      * https://nodejs.org/api/http2.html#http2_class_clienthttp2session
      */
     disableConcurrentStreams?: boolean;
+    /**
+     * Maximum number of concurrent Http2Stream instances per ClientHttp2Session. Each session
+     * may have up to 2^31-1 Http2Stream instances over its lifetime.
+     * This value must be greater than or equal to 0.
+     * https://nodejs.org/api/http2.html#class-http2stream
+     */
+    maxConcurrentStreams?: number;
 }
 export declare class NodeHttp2Handler implements HttpHandler {
     private config?;
@@ -29,29 +36,15 @@ export declare class NodeHttp2Handler implements HttpHandler {
     readonly metadata: {
         handlerProtocol: string;
     };
-    private sessionCache;
+    private readonly connectionManager;
     constructor(options?: NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>);
     destroy(): void;
     handle(request: HttpRequest, { abortSignal }?: HttpHandlerOptions): Promise<{
         response: HttpResponse;
     }>;
-    /**
-     * Returns a session for the given URL.
-     *
-     * @param authority The URL to create a session for.
-     * @param disableConcurrentStreams If true, a new session will be created for each request.
-     * @returns A session for the given URL.
-     */
-    private getSession;
     /**
      * Destroys a session.
      * @param session The session to destroy.
      */
     private destroySession;
-    /**
-     * Delete a session from the connection pool.
-     * @param authority The authority of the session to delete.
-     * @param session The session to delete.
-     */
-    private deleteSessionFromCache;
 }

package/node_modules/@aws-sdk/node-http-handler/dist-types/ts3.4/node-http-handler.d.ts

@@ -4,10 +4,12 @@ import { Agent as hAgent } from "http";
 import { Agent as hsAgent } from "https";
 export interface NodeHttpHandlerOptions {
   connectionTimeout?: number;
+  requestTimeout?: number;
   socketTimeout?: number;
   httpAgent?: hAgent;
   httpsAgent?: hsAgent;
 }
+export declare const DEFAULT_REQUEST_TIMEOUT = 0;
 export declare class NodeHttpHandler implements HttpHandler {
   private config?;
   private readonly configProvider;

package/node_modules/@aws-sdk/node-http-handler/dist-types/ts3.4/node-http2-connection-manager.d.ts

@@ -0,0 +1,24 @@
+import { RequestContext } from "@aws-sdk/types";
+import { ConnectConfiguration } from "@aws-sdk/types/src/connection/config";
+import {
+  ConnectionManager,
+  ConnectionManagerConfiguration,
+} from "@aws-sdk/types/src/connection/manager";
+import { ClientHttp2Session } from "http2";
+export declare class NodeHttp2ConnectionManager
+  implements ConnectionManager<ClientHttp2Session>
+{
+  constructor(config: ConnectionManagerConfiguration);
+  private config;
+  private readonly sessionCache;
+  lease(
+    requestContext: RequestContext,
+    connectionConfiguration: ConnectConfiguration
+  ): ClientHttp2Session;
+  deleteSession(authority: string, session: ClientHttp2Session): void;
+  release(requestContext: RequestContext, session: ClientHttp2Session): void;
+  destroy(): void;
+  setMaxConcurrentStreams(maxConcurrentStreams: number): void;
+  setDisableConcurrentStreams(disableConcurrentStreams: boolean): void;
+  private getUrlString;
+}

package/node_modules/@aws-sdk/node-http-handler/dist-types/ts3.4/node-http2-connection-pool.d.ts

@@ -0,0 +1,14 @@
+import { ConnectionPool } from "@aws-sdk/types/src/connection/pool";
+import { ClientHttp2Session } from "http2";
+export declare class NodeHttp2ConnectionPool
+  implements ConnectionPool<ClientHttp2Session>
+{
+  private sessions;
+  constructor(sessions?: ClientHttp2Session[]);
+  poll(): ClientHttp2Session | void;
+  offerLast(session: ClientHttp2Session): void;
+  contains(session: ClientHttp2Session): boolean;
+  remove(session: ClientHttp2Session): void;
+  [Symbol.iterator](): IterableIterator<ClientHttp2Session>;
+  destroy(connection: ClientHttp2Session): void;
+}

package/node_modules/@aws-sdk/node-http-handler/dist-types/ts3.4/node-http2-handler.d.ts

@@ -4,6 +4,7 @@ export interface NodeHttp2HandlerOptions {
   requestTimeout?: number;
   sessionTimeout?: number;
   disableConcurrentStreams?: boolean;
+  maxConcurrentStreams?: number;
 }
 export declare class NodeHttp2Handler implements HttpHandler {
   private config?;
@@ -11,7 +12,7 @@ export declare class NodeHttp2Handler implements HttpHandler {
   readonly metadata: {
     handlerProtocol: string;
   };
-  private sessionCache;
+  private readonly connectionManager;
   constructor(
     options?: NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>
   );
@@ -22,7 +23,5 @@ export declare class NodeHttp2Handler implements HttpHandler {
   ): Promise<{
     response: HttpResponse;
   }>;
-  private getSession;
   private destroySession;
-  private deleteSessionFromCache;
 }

package/node_modules/@aws-sdk/node-http-handler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/node-http-handler",
-  "version": "3.295.0",
+  "version": "3.296.0",
   "description": "Provides a way to make requests",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
@@ -22,10 +22,10 @@
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
   "dependencies": {
-    "@aws-sdk/abort-controller": "3.295.0",
-    "@aws-sdk/protocol-http": "3.295.0",
-    "@aws-sdk/querystring-builder": "3.295.0",
-    "@aws-sdk/types": "3.295.0",
+    "@aws-sdk/abort-controller": "3.296.0",
+    "@aws-sdk/protocol-http": "3.296.0",
+    "@aws-sdk/querystring-builder": "3.296.0",
+    "@aws-sdk/types": "3.296.0",
     "tslib": "^2.5.0"
   },
   "devDependencies": {

package/node_modules/@aws-sdk/property-provider/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/property-provider",
-  "version": "3.295.0",
+  "version": "3.296.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,7 +20,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.295.0",
+    "@aws-sdk/types": "3.296.0",
     "tslib": "^2.5.0"
   },
   "engines": {

package/node_modules/@aws-sdk/protocol-http/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/protocol-http",
-  "version": "3.295.0",
+  "version": "3.296.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -21,7 +21,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.295.0",
+    "@aws-sdk/types": "3.296.0",
     "tslib": "^2.5.0"
   },
   "engines": {

package/node_modules/@aws-sdk/querystring-builder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/querystring-builder",
-  "version": "3.295.0",
+  "version": "3.296.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,7 +20,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.295.0",
+    "@aws-sdk/types": "3.296.0",
     "@aws-sdk/util-uri-escape": "3.295.0",
     "tslib": "^2.5.0"
   },

package/node_modules/@aws-sdk/querystring-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/querystring-parser",
-  "version": "3.295.0",
+  "version": "3.296.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,7 +20,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.295.0",
+    "@aws-sdk/types": "3.296.0",
     "tslib": "^2.5.0"
   },
   "engines": {