@code-yeongyu/senpi 2026.5.20-4 → 2026.5.21

package/node_modules/@smithy/node-http-handler/dist-es/set-request-timeout.js

@@ -0,0 +1,21 @@
+import { timing } from "./timing";
+export const setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => {
+    if (timeoutInMs) {
+        return timing.setTimeout(() => {
+            let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
+            if (throwOnRequestTimeout) {
+                const error = Object.assign(new Error(msg), {
+                    name: "TimeoutError",
+                    code: "ETIMEDOUT",
+                });
+                req.destroy(error);
+                reject(error);
+            }
+            else {
+                msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
+                logger?.warn?.(msg);
+            }
+        }, timeoutInMs);
+    }
+    return -1;
+};

package/node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js

@@ -0,0 +1,22 @@
+import { timing } from "./timing";
+const DEFER_EVENT_LISTENER_TIME = 3000;
+export const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME) => {
+    if (keepAlive !== true) {
+        return -1;
+    }
+    const registerListener = () => {
+        if (request.socket) {
+            request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+        }
+        else {
+            request.on("socket", (socket) => {
+                socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+            });
+        }
+    };
+    if (deferTimeMs === 0) {
+        registerListener();
+        return 0;
+    }
+    return timing.setTimeout(registerListener, deferTimeMs);
+};

package/node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js

@@ -0,0 +1,23 @@
+import { timing } from "./timing";
+const DEFER_EVENT_LISTENER_TIME = 3000;
+export const setSocketTimeout = (request, reject, timeoutInMs = 0) => {
+    const registerTimeout = (offset) => {
+        const timeout = timeoutInMs - offset;
+        const onTimeout = () => {
+            request.destroy();
+            reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
+        };
+        if (request.socket) {
+            request.socket.setTimeout(timeout, onTimeout);
+            request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
+        }
+        else {
+            request.setTimeout(timeout, onTimeout);
+        }
+    };
+    if (0 < timeoutInMs && timeoutInMs < 6000) {
+        registerTimeout(0);
+        return 0;
+    }
+    return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+};

package/node_modules/@smithy/node-http-handler/dist-es/stream-collector/collector.js

@@ -0,0 +1,8 @@
+import { Writable } from "stream";
+export class Collector extends Writable {
+    bufferedBytes = [];
+    _write(chunk, encoding, callback) {
+        this.bufferedBytes.push(chunk);
+        callback();
+    }
+}

package/node_modules/@smithy/node-http-handler/dist-es/stream-collector/index.js

@@ -0,0 +1,41 @@
+import { Collector } from "./collector";
+export const streamCollector = (stream) => {
+    if (isReadableStreamInstance(stream)) {
+        return collectReadableStream(stream);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            resolve(bytes);
+        });
+    });
+};
+const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
+async function collectReadableStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            length += value.length;
+        }
+        isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}

package/node_modules/@smithy/node-http-handler/dist-es/stream-collector/readable.mock.js

@@ -0,0 +1,21 @@
+import { Readable } from "stream";
+export class ReadFromBuffers extends Readable {
+    buffersToRead;
+    numBuffersRead = 0;
+    errorAfter;
+    constructor(options) {
+        super(options);
+        this.buffersToRead = options.buffers;
+        this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
+    }
+    _read(size) {
+        if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) {
+            this.emit("error", new Error("Mock Error"));
+            return;
+        }
+        if (this.numBuffersRead >= this.buffersToRead.length) {
+            return this.push(null);
+        }
+        return this.push(this.buffersToRead[this.numBuffersRead++]);
+    }
+}

package/node_modules/@smithy/node-http-handler/dist-es/timing.js

@@ -0,0 +1,4 @@
+export const timing = {
+    setTimeout: (cb, ms) => setTimeout(cb, ms),
+    clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+};

package/node_modules/@smithy/node-http-handler/dist-es/write-request-body.js

@@ -0,0 +1,56 @@
+import { Readable } from "stream";
+import { timing } from "./timing";
+const MIN_WAIT_TIME = 6_000;
+export async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
+    const headers = request.headers ?? {};
+    const expect = headers["Expect"] || headers["expect"];
+    let timeoutId = -1;
+    let sendBody = true;
+    if (expect === "100-continue") {
+        sendBody = await Promise.race([
+            new Promise((resolve) => {
+                timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+            }),
+            new Promise((resolve) => {
+                httpRequest.on("continue", () => {
+                    timing.clearTimeout(timeoutId);
+                    resolve(true);
+                });
+                httpRequest.on("response", () => {
+                    timing.clearTimeout(timeoutId);
+                    resolve(false);
+                });
+                httpRequest.on("error", () => {
+                    timing.clearTimeout(timeoutId);
+                    resolve(false);
+                });
+            }),
+        ]);
+    }
+    if (sendBody) {
+        writeBody(httpRequest, request.body);
+    }
+}
+function writeBody(httpRequest, body) {
+    if (body instanceof Readable) {
+        body.pipe(httpRequest);
+        return;
+    }
+    if (body) {
+        if (Buffer.isBuffer(body) || typeof body === "string") {
+            httpRequest.end(body);
+            return;
+        }
+        const uint8 = body;
+        if (typeof uint8 === "object" &&
+            uint8.buffer &&
+            typeof uint8.byteOffset === "number" &&
+            typeof uint8.byteLength === "number") {
+            httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
+            return;
+        }
+        httpRequest.end(Buffer.from(body));
+        return;
+    }
+    httpRequest.end();
+}

package/node_modules/@smithy/node-http-handler/dist-types/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Node.js system error codes that indicate timeout.
+ * @deprecated use NODEJS_TIMEOUT_ERROR_CODES from @smithy/service-error-classification/constants
+ */
+export declare const NODEJS_TIMEOUT_ERROR_CODES: string[];

package/node_modules/@smithy/node-http-handler/dist-types/get-transformed-headers.d.ts

@@ -0,0 +1,4 @@
+import type { HeaderBag } from "@smithy/types";
+import type { IncomingHttpHeaders } from "http2";
+declare const getTransformedHeaders: (headers: IncomingHttpHeaders) => HeaderBag;
+export { getTransformedHeaders };

package/node_modules/@smithy/node-http-handler/dist-types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./node-http-handler";
+export * from "./node-http2-handler";
+export * from "./stream-collector";

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

@@ -0,0 +1,46 @@
+import type { HttpHandler, HttpRequest } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/protocol-http";
+import type { Logger, NodeHttpHandlerOptions } from "@smithy/types";
+import type { HttpHandlerOptions, Provider } from "@smithy/types";
+import { Agent as hAgent } from "http";
+import { Agent as hsAgent } from "https";
+export { NodeHttpHandlerOptions };
+/**
+ * @public
+ * A default of 0 means no timeout.
+ */
+export declare const DEFAULT_REQUEST_TIMEOUT = 0;
+/**
+ * @public
+ * A request handler that uses the Node.js http and https modules.
+ */
+export declare class NodeHttpHandler implements HttpHandler<NodeHttpHandlerOptions> {
+    private config?;
+    private configProvider;
+    private socketWarningTimestamp;
+    readonly metadata: {
+        handlerProtocol: string;
+    };
+    /**
+     * @returns the input if it is an HttpHandler of any class,
+     * or instantiates a new instance of this handler.
+     */
+    static create(instanceOrOptions?: HttpHandler<any> | NodeHttpHandlerOptions | Provider<NodeHttpHandlerOptions | void>): NodeHttpHandler | HttpHandler<any>;
+    /**
+     * @internal
+     *
+     * @param agent - http(s) agent in use by the NodeHttpHandler instance.
+     * @param socketWarningTimestamp - last socket usage check timestamp.
+     * @param logger - channel for the warning.
+     * @returns timestamp of last emitted warning.
+     */
+    static checkSocketUsage(agent: hAgent | hsAgent, socketWarningTimestamp: number, logger?: Logger): number;
+    constructor(options?: NodeHttpHandlerOptions | Provider<NodeHttpHandlerOptions | void>);
+    private resolveDefaultConfig;
+    destroy(): void;
+    handle(request: HttpRequest, { abortSignal, requestTimeout }?: HttpHandlerOptions): Promise<{
+        response: HttpResponse;
+    }>;
+    updateHttpClientConfig(key: keyof NodeHttpHandlerOptions, value: NodeHttpHandlerOptions[typeof key]): void;
+    httpHandlerConfigs(): NodeHttpHandlerOptions;
+}

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

@@ -0,0 +1,24 @@
+import type { RequestContext } from "@smithy/types";
+import type { ConnectConfiguration } from "@smithy/types";
+import type { ConnectionManager, ConnectionManagerConfiguration } from "@smithy/types";
+import type { ClientHttp2Session } from "http2";
+/**
+ * @public
+ */
+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/@smithy/node-http-handler/dist-types/node-http2-connection-pool.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectionPool } from "@smithy/types";
+import type { 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](): ArrayIterator<ClientHttp2Session>;
+    destroy(connection: ClientHttp2Session): void;
+}

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

@@ -0,0 +1,63 @@
+import type { HttpHandler, HttpRequest } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/protocol-http";
+import type { HttpHandlerOptions, Provider } from "@smithy/types";
+/**
+ * Represents the http2 options that can be passed to a node http2 client.
+ * @public
+ */
+export interface NodeHttp2HandlerOptions {
+    /**
+     * The maximum time in milliseconds that a stream may remain idle before it
+     * is closed.
+     */
+    requestTimeout?: number;
+    /**
+     * The maximum time in milliseconds that a session or socket may remain idle
+     * before it is closed.
+     * https://nodejs.org/docs/latest-v12.x/api/http2.html#http2_http2session_and_sockets
+     */
+    sessionTimeout?: number;
+    /**
+     * Disables processing concurrent streams on a ClientHttp2Session instance. When set
+     * 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;
+}
+/**
+ * A request handler using the node:http2 package.
+ * @public
+ */
+export declare class NodeHttp2Handler implements HttpHandler<NodeHttp2HandlerOptions> {
+    private config?;
+    private configProvider;
+    readonly metadata: {
+        handlerProtocol: string;
+    };
+    private readonly connectionManager;
+    /**
+     * @returns the input if it is an HttpHandler of any class,
+     * or instantiates a new instance of this handler.
+     */
+    static create(instanceOrOptions?: HttpHandler<any> | NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>): HttpHandler<any> | NodeHttp2Handler;
+    constructor(options?: NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>);
+    destroy(): void;
+    handle(request: HttpRequest, { abortSignal, requestTimeout }?: HttpHandlerOptions): Promise<{
+        response: HttpResponse;
+    }>;
+    updateHttpClientConfig(key: keyof NodeHttp2HandlerOptions, value: NodeHttp2HandlerOptions[typeof key]): void;
+    httpHandlerConfigs(): NodeHttp2HandlerOptions;
+    /**
+     * Destroys a session.
+     * @param session - the session to destroy.
+     */
+    private destroySession;
+}

package/node_modules/@smithy/node-http-handler/dist-types/readable.mock.d.ts

@@ -0,0 +1,13 @@
+import type { ReadableOptions } from "stream";
+import { Readable } from "stream";
+export interface ReadFromBuffersOptions extends ReadableOptions {
+    buffers: Buffer[];
+    errorAfter?: number;
+}
+export declare class ReadFromBuffers extends Readable {
+    private buffersToRead;
+    private numBuffersRead;
+    private errorAfter;
+    constructor(options: ReadFromBuffersOptions);
+    _read(): boolean | undefined;
+}

package/node_modules/@smithy/node-http-handler/dist-types/server.mock.d.ts

@@ -0,0 +1,12 @@
+import type { HttpResponse } from "@smithy/types";
+import type { IncomingMessage, Server as HttpServer, ServerResponse } from "http";
+import type { Http2Server } from "http2";
+import type { Server as HttpsServer } from "https";
+export declare const createResponseFunction: (httpResp: HttpResponse) => (request: IncomingMessage, response: ServerResponse) => void;
+export declare const createResponseFunctionWithDelay: (httpResp: HttpResponse, delay: number) => (request: IncomingMessage, response: ServerResponse) => void;
+export declare const createContinueResponseFunction: (httpResp: HttpResponse) => (request: IncomingMessage, response: ServerResponse) => void;
+export declare const createMockHttpsServer: () => HttpsServer;
+export declare const createMockHttpServer: () => HttpServer;
+export declare const createMockHttp2Server: () => Http2Server;
+export declare const createMirrorResponseFunction: (httpResp: HttpResponse) => (request: IncomingMessage, response: ServerResponse) => void;
+export declare const getResponseBody: (response: HttpResponse) => Promise<string>;

package/node_modules/@smithy/node-http-handler/dist-types/set-connection-timeout.d.ts

@@ -0,0 +1,2 @@
+import type { ClientRequest } from "http";
+export declare const setConnectionTimeout: (request: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number) => NodeJS.Timeout | number;

package/node_modules/@smithy/node-http-handler/dist-types/set-request-timeout.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from "@smithy/types";
+import type { ClientRequest } from "http";
+/**
+ * @internal
+ */
+export declare const setRequestTimeout: (req: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number, throwOnRequestTimeout?: boolean, logger?: Logger) => number;

package/node_modules/@smithy/node-http-handler/dist-types/set-socket-keep-alive.d.ts

@@ -0,0 +1,6 @@
+import type { ClientRequest } from "http";
+export interface SocketKeepAliveOptions {
+    keepAlive: boolean;
+    keepAliveMsecs?: number;
+}
+export declare const setSocketKeepAlive: (request: ClientRequest, { keepAlive, keepAliveMsecs }: SocketKeepAliveOptions, deferTimeMs?: number) => NodeJS.Timeout | number;

package/node_modules/@smithy/node-http-handler/dist-types/set-socket-timeout.d.ts

@@ -0,0 +1,2 @@
+import type { ClientRequest } from "http";
+export declare const setSocketTimeout: (request: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number) => NodeJS.Timeout | number;

package/node_modules/@smithy/node-http-handler/dist-types/stream-collector/collector.d.ts

@@ -0,0 +1,5 @@
+import { Writable } from "stream";
+export declare class Collector extends Writable {
+    readonly bufferedBytes: Buffer[];
+    _write(chunk: Buffer, encoding: string, callback: (err?: Error) => void): void;
+}

package/node_modules/@smithy/node-http-handler/dist-types/stream-collector/index.d.ts

@@ -0,0 +1,6 @@
+import type { StreamCollector } from "@smithy/types";
+/**
+ * @internal
+ * Converts a stream to a byte array.
+ */
+export declare const streamCollector: StreamCollector;

package/node_modules/@smithy/node-http-handler/dist-types/stream-collector/readable.mock.d.ts

@@ -0,0 +1,13 @@
+import type { ReadableOptions } from "stream";
+import { Readable } from "stream";
+export interface ReadFromBuffersOptions extends ReadableOptions {
+    buffers: Buffer[];
+    errorAfter?: number;
+}
+export declare class ReadFromBuffers extends Readable {
+    private buffersToRead;
+    private numBuffersRead;
+    private errorAfter;
+    constructor(options: ReadFromBuffersOptions);
+    _read(size: number): boolean | undefined;
+}

package/node_modules/@smithy/node-http-handler/dist-types/timing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ * For test spies.
+ */
+export declare const timing: {
+    setTimeout: (cb: (...ignored: any[]) => void | unknown, ms?: number) => number;
+    clearTimeout: (timeoutId: string | number | undefined | unknown) => void;
+};

package/node_modules/@smithy/node-http-handler/dist-types/ts3.4/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Node.js system error codes that indicate timeout.
+ * @deprecated use NODEJS_TIMEOUT_ERROR_CODES from @smithy/service-error-classification/constants
+ */
+export declare const NODEJS_TIMEOUT_ERROR_CODES: string[];

package/node_modules/@smithy/node-http-handler/dist-types/ts3.4/get-transformed-headers.d.ts

@@ -0,0 +1,4 @@
+import { HeaderBag } from "@smithy/types";
+import { IncomingHttpHeaders } from "http2";
+declare const getTransformedHeaders: (headers: IncomingHttpHeaders) => HeaderBag;
+export { getTransformedHeaders };

package/node_modules/@smithy/node-http-handler/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./node-http-handler";
+export * from "./node-http2-handler";
+export * from "./stream-collector";

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

@@ -0,0 +1,46 @@
+import { HttpHandler, HttpRequest } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/protocol-http";
+import { Logger, NodeHttpHandlerOptions } from "@smithy/types";
+import { HttpHandlerOptions, Provider } from "@smithy/types";
+import { Agent as hAgent } from "http";
+import { Agent as hsAgent } from "https";
+export { NodeHttpHandlerOptions };
+/**
+ * @public
+ * A default of 0 means no timeout.
+ */
+export declare const DEFAULT_REQUEST_TIMEOUT = 0;
+/**
+ * @public
+ * A request handler that uses the Node.js http and https modules.
+ */
+export declare class NodeHttpHandler implements HttpHandler<NodeHttpHandlerOptions> {
+    private config?;
+    private configProvider;
+    private socketWarningTimestamp;
+    readonly metadata: {
+        handlerProtocol: string;
+    };
+    /**
+     * @returns the input if it is an HttpHandler of any class,
+     * or instantiates a new instance of this handler.
+     */
+    static create(instanceOrOptions?: HttpHandler<any> | NodeHttpHandlerOptions | Provider<NodeHttpHandlerOptions | void>): NodeHttpHandler | HttpHandler<any>;
+    /**
+     * @internal
+     *
+     * @param agent - http(s) agent in use by the NodeHttpHandler instance.
+     * @param socketWarningTimestamp - last socket usage check timestamp.
+     * @param logger - channel for the warning.
+     * @returns timestamp of last emitted warning.
+     */
+    static checkSocketUsage(agent: hAgent | hsAgent, socketWarningTimestamp: number, logger?: Logger): number;
+    constructor(options?: NodeHttpHandlerOptions | Provider<NodeHttpHandlerOptions | void>);
+    private resolveDefaultConfig;
+    destroy(): void;
+    handle(request: HttpRequest, { abortSignal, requestTimeout }?: HttpHandlerOptions): Promise<{
+        response: HttpResponse;
+    }>;
+    updateHttpClientConfig(key: keyof NodeHttpHandlerOptions, value: NodeHttpHandlerOptions[typeof key]): void;
+    httpHandlerConfigs(): NodeHttpHandlerOptions;
+}

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

@@ -0,0 +1,24 @@
+import { RequestContext } from "@smithy/types";
+import { ConnectConfiguration } from "@smithy/types";
+import { ConnectionManager, ConnectionManagerConfiguration } from "@smithy/types";
+import { ClientHttp2Session } from "http2";
+/**
+ * @public
+ */
+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/@smithy/node-http-handler/dist-types/ts3.4/node-http2-connection-pool.d.ts

@@ -0,0 +1,12 @@
+import { ConnectionPool } from "@smithy/types";
+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](): ArrayIterator<ClientHttp2Session>;
+    destroy(connection: ClientHttp2Session): void;
+}

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

@@ -0,0 +1,63 @@
+import { HttpHandler, HttpRequest } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/protocol-http";
+import { HttpHandlerOptions, Provider } from "@smithy/types";
+/**
+ * Represents the http2 options that can be passed to a node http2 client.
+ * @public
+ */
+export interface NodeHttp2HandlerOptions {
+    /**
+     * The maximum time in milliseconds that a stream may remain idle before it
+     * is closed.
+     */
+    requestTimeout?: number;
+    /**
+     * The maximum time in milliseconds that a session or socket may remain idle
+     * before it is closed.
+     * https://nodejs.org/docs/latest-v12.x/api/http2.html#http2_http2session_and_sockets
+     */
+    sessionTimeout?: number;
+    /**
+     * Disables processing concurrent streams on a ClientHttp2Session instance. When set
+     * 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;
+}
+/**
+ * A request handler using the node:http2 package.
+ * @public
+ */
+export declare class NodeHttp2Handler implements HttpHandler<NodeHttp2HandlerOptions> {
+    private config?;
+    private configProvider;
+    readonly metadata: {
+        handlerProtocol: string;
+    };
+    private readonly connectionManager;
+    /**
+     * @returns the input if it is an HttpHandler of any class,
+     * or instantiates a new instance of this handler.
+     */
+    static create(instanceOrOptions?: HttpHandler<any> | NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>): HttpHandler<any> | NodeHttp2Handler;
+    constructor(options?: NodeHttp2HandlerOptions | Provider<NodeHttp2HandlerOptions | void>);
+    destroy(): void;
+    handle(request: HttpRequest, { abortSignal, requestTimeout }?: HttpHandlerOptions): Promise<{
+        response: HttpResponse;
+    }>;
+    updateHttpClientConfig(key: keyof NodeHttp2HandlerOptions, value: NodeHttp2HandlerOptions[typeof key]): void;
+    httpHandlerConfigs(): NodeHttp2HandlerOptions;
+    /**
+     * Destroys a session.
+     * @param session - the session to destroy.
+     */
+    private destroySession;
+}

package/node_modules/@smithy/node-http-handler/dist-types/ts3.4/readable.mock.d.ts

@@ -0,0 +1,13 @@
+import { ReadableOptions } from "stream";
+import { Readable } from "stream";
+export interface ReadFromBuffersOptions extends ReadableOptions {
+    buffers: Buffer[];
+    errorAfter?: number;
+}
+export declare class ReadFromBuffers extends Readable {
+    private buffersToRead;
+    private numBuffersRead;
+    private errorAfter;
+    constructor(options: ReadFromBuffersOptions);
+    _read(): boolean | undefined;
+}