@aws-sdk/middleware-websocket 3.305.0

package/dist-es/get-event-signing-stream.js

@@ -0,0 +1,38 @@
+import { fromHex } from "@aws-sdk/util-hex-encoding";
+export const getEventSigningTransformStream = (initialSignature, eventSigner, eventStreamCodec) => {
+    let priorSignature = initialSignature;
+    const transformer = {
+        start() { },
+        async transform(chunk, controller) {
+            try {
+                const now = new Date();
+                const dateHeader = {
+                    ":date": { type: "timestamp", value: now },
+                };
+                const signature = await eventSigner.sign({
+                    payload: chunk,
+                    headers: eventStreamCodec.formatHeaders(dateHeader),
+                }, {
+                    priorSignature,
+                    signingDate: now,
+                });
+                priorSignature = signature;
+                const serializedSigned = eventStreamCodec.encode({
+                    headers: {
+                        ...dateHeader,
+                        ":chunk-signature": {
+                            type: "binary",
+                            value: fromHex(signature),
+                        },
+                    },
+                    body: chunk,
+                });
+                controller.enqueue(serializedSigned);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    };
+    return new TransformStream({ ...transformer });
+};

package/dist-es/index.js

@@ -0,0 +1,4 @@
+export * from "./configuration";
+export * from "./eventstream-payload-handler-provider";
+export * from "./plugin";
+export * from "./websocket-fetch-handler";

package/dist-es/middleware-session-id.js

@@ -0,0 +1,17 @@
+export const injectSessionIdMiddleware = () => (next) => async (args) => {
+    const requestParams = {
+        ...args.input,
+    };
+    const response = await next(args);
+    const output = response.output;
+    if (requestParams.SessionId && output.SessionId == null) {
+        output.SessionId = requestParams.SessionId;
+    }
+    return response;
+};
+export const injectSessionIdMiddlewareOptions = {
+    step: "initialize",
+    name: "injectSessionIdMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    override: true,
+};

package/dist-es/middleware-websocket-endpoint.js

@@ -0,0 +1,31 @@
+import { HttpRequest } from "@aws-sdk/protocol-http";
+export const websocketEndpointMiddleware = (config, options) => (next) => (args) => {
+    const { request } = args;
+    if (HttpRequest.isInstance(request) &&
+        config.requestHandler.metadata?.handlerProtocol?.toLowerCase().includes("websocket")) {
+        request.protocol = "wss:";
+        request.method = "GET";
+        request.path = `${request.path}-websocket`;
+        const { headers } = request;
+        delete headers["Content-Type"];
+        delete headers["x-amz-content-sha256"];
+        for (const name of Object.keys(headers)) {
+            if (name.indexOf(options.headerPrefix) === 0) {
+                const chunkedName = name.replace(options.headerPrefix, "");
+                request.query[chunkedName] = headers[name];
+            }
+        }
+        if (headers["x-amz-user-agent"]) {
+            request.query["user-agent"] = headers["x-amz-user-agent"];
+        }
+        request.headers = { host: headers.host ?? request.hostname };
+    }
+    return next(args);
+};
+export const websocketEndpointMiddlewareOptions = {
+    name: "websocketEndpointMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    relation: "after",
+    toMiddleware: "eventStreamHeaderMiddleware",
+    override: true,
+};

package/dist-es/plugin.js

@@ -0,0 +1,8 @@
+import { injectSessionIdMiddleware, injectSessionIdMiddlewareOptions } from "./middleware-session-id";
+import { websocketEndpointMiddleware, websocketEndpointMiddlewareOptions } from "./middleware-websocket-endpoint";
+export const getWebSocketPlugin = (config, options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);
+        clientStack.add(injectSessionIdMiddleware(), injectSessionIdMiddlewareOptions);
+    },
+});

package/dist-es/utils.js

@@ -0,0 +1 @@
+export const isWebSocketRequest = (request) => request.protocol === "ws:" || request.protocol === "wss:";

package/dist-es/websocket-fetch-handler.js

@@ -0,0 +1,139 @@
+import { iterableToReadableStream, readableStreamtoIterable } from "@aws-sdk/eventstream-serde-browser";
+import { FetchHttpHandler } from "@aws-sdk/fetch-http-handler";
+import { HttpResponse } from "@aws-sdk/protocol-http";
+import { formatUrl } from "@aws-sdk/util-format-url";
+import { isWebSocketRequest } from "./utils";
+const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 2000;
+export class WebSocketFetchHandler {
+    constructor(options, httpHandler = new FetchHttpHandler()) {
+        this.metadata = {
+            handlerProtocol: "websocket/h1.1",
+        };
+        this.sockets = {};
+        this.httpHandler = httpHandler;
+        if (typeof options === "function") {
+            this.configPromise = options().then((opts) => opts ?? {});
+        }
+        else {
+            this.configPromise = Promise.resolve(options ?? {});
+        }
+    }
+    destroy() {
+        for (const [key, sockets] of Object.entries(this.sockets)) {
+            for (const socket of sockets) {
+                socket.close(1000, `Socket closed through destroy() call`);
+            }
+            delete this.sockets[key];
+        }
+    }
+    async handle(request) {
+        if (!isWebSocketRequest(request)) {
+            return this.httpHandler.handle(request);
+        }
+        const url = formatUrl(request);
+        const socket = new WebSocket(url);
+        if (!this.sockets[url]) {
+            this.sockets[url] = [];
+        }
+        this.sockets[url].push(socket);
+        socket.binaryType = "arraybuffer";
+        const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = await this.configPromise;
+        await this.waitForReady(socket, connectionTimeout);
+        const { body } = request;
+        const bodyStream = getIterator(body);
+        const asyncIterable = this.connect(socket, bodyStream);
+        const outputPayload = toReadableStream(asyncIterable);
+        return {
+            response: new HttpResponse({
+                statusCode: 200,
+                body: outputPayload,
+            }),
+        };
+    }
+    removeNotUsableSockets(url) {
+        this.sockets[url] = this.sockets[url].filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
+    }
+    waitForReady(socket, connectionTimeout) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.removeNotUsableSockets(socket.url);
+                reject({
+                    $metadata: {
+                        httpStatusCode: 500,
+                    },
+                });
+            }, connectionTimeout);
+            socket.onopen = () => {
+                clearTimeout(timeout);
+                resolve();
+            };
+        });
+    }
+    connect(socket, data) {
+        let streamError = undefined;
+        const outputStream = {
+            [Symbol.asyncIterator]: () => ({
+                next: () => {
+                    return new Promise((resolve, reject) => {
+                        let socketErrorOccurred = false;
+                        socket.onerror = (error) => {
+                            socketErrorOccurred = true;
+                            socket.close();
+                            reject(error);
+                        };
+                        socket.onclose = () => {
+                            this.removeNotUsableSockets(socket.url);
+                            if (socketErrorOccurred)
+                                return;
+                            if (streamError) {
+                                reject(streamError);
+                            }
+                            else {
+                                resolve({
+                                    done: true,
+                                    value: undefined,
+                                });
+                            }
+                        };
+                        socket.onmessage = (event) => {
+                            resolve({
+                                done: false,
+                                value: new Uint8Array(event.data),
+                            });
+                        };
+                    });
+                },
+            }),
+        };
+        const send = async () => {
+            try {
+                for await (const inputChunk of data) {
+                    socket.send(inputChunk);
+                }
+            }
+            catch (err) {
+                streamError = err;
+            }
+            finally {
+                socket.close(1000);
+            }
+        };
+        send();
+        return outputStream;
+    }
+}
+const getIterator = (stream) => {
+    if (stream[Symbol.asyncIterator]) {
+        return stream;
+    }
+    if (isReadableStream(stream)) {
+        return readableStreamtoIterable(stream);
+    }
+    return {
+        [Symbol.asyncIterator]: async function* () {
+            yield stream;
+        },
+    };
+};
+const toReadableStream = (asyncIterable) => typeof ReadableStream === "function" ? iterableToReadableStream(asyncIterable) : asyncIterable;
+const isReadableStream = (payload) => typeof ReadableStream === "function" && payload instanceof ReadableStream;

package/dist-types/EventStreamPayloadHandler.d.ts

@@ -0,0 +1,19 @@
+import { Decoder, Encoder, EventSigner, EventStreamPayloadHandler as IEventStreamPayloadHandler, FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext, MetadataBearer, Provider } from "@aws-sdk/types";
+export interface EventStreamPayloadHandlerOptions {
+    eventSigner: Provider<EventSigner>;
+    utf8Encoder: Encoder;
+    utf8Decoder: Decoder;
+}
+/**
+ * A handler that control the eventstream payload flow:
+ * 1. Pause stream for initial request.
+ * 2. Close the stream if initial request fails.
+ * 3. Start piping payload when connection is established.
+ * 4. Sign the payload after payload stream starting to flow.
+ */
+export declare class EventStreamPayloadHandler implements IEventStreamPayloadHandler {
+    private readonly eventSigner;
+    private readonly eventStreamCodec;
+    constructor(options: EventStreamPayloadHandlerOptions);
+    handle<T extends MetadataBearer>(next: FinalizeHandler<any, T>, args: FinalizeHandlerArguments<any>, context?: HandlerExecutionContext): Promise<FinalizeHandlerOutput<T>>;
+}

package/dist-types/WebsocketSignatureV4.d.ts

@@ -0,0 +1,10 @@
+import { SignatureV4 as BaseSignatureV4 } from "@aws-sdk/signature-v4";
+import { HttpRequest as IHttpRequest, RequestPresigner, RequestPresigningArguments, RequestSigner, RequestSigningArguments } from "@aws-sdk/types";
+export declare class WebsocketSignatureV4 implements RequestSigner, RequestPresigner {
+    private readonly signer;
+    constructor(options: {
+        signer: BaseSignatureV4;
+    });
+    presign(originalRequest: IHttpRequest, options?: RequestPresigningArguments): Promise<IHttpRequest>;
+    sign(toSign: IHttpRequest, options?: RequestSigningArguments): Promise<IHttpRequest>;
+}

package/dist-types/configuration.d.ts

@@ -0,0 +1,19 @@
+import { AuthScheme, RequestHandler, RequestSigner } from "@aws-sdk/types";
+export interface WebSocketInputConfig {
+}
+interface PreviouslyResolved {
+    signer: (authScheme: AuthScheme) => Promise<RequestSigner>;
+    requestHandler: RequestHandler<any, any>;
+}
+export interface WebSocketResolvedConfig {
+    /**
+     * Resolved value of input config {@link AwsAuthInputConfig.signer}
+     */
+    signer: (authScheme: AuthScheme) => Promise<RequestSigner>;
+    /**
+     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
+     */
+    requestHandler: RequestHandler<any, any>;
+}
+export declare const resolveWebSocketConfig: <T>(input: T & WebSocketInputConfig & PreviouslyResolved) => T & WebSocketResolvedConfig;
+export {};

package/dist-types/eventstream-payload-handler-provider.d.ts

@@ -0,0 +1,3 @@
+import { EventStreamPayloadHandlerProvider } from "@aws-sdk/types";
+/** NodeJS event stream utils provider */
+export declare const eventStreamPayloadHandlerProvider: EventStreamPayloadHandlerProvider;

package/dist-types/get-event-signing-stream.d.ts

@@ -0,0 +1,8 @@
+import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
+import { EventSigner } from "@aws-sdk/types";
+/**
+ * Get a transform stream that signs the eventstream
+ * Implementation replicated from @aws-sdk/eventstream-handler-node::EventSigningStream
+ * but modified to be compatible with WHATWG stream interface
+ */
+export declare const getEventSigningTransformStream: (initialSignature: string, eventSigner: EventSigner, eventStreamCodec: EventStreamCodec) => TransformStream<Uint8Array, Uint8Array>;

package/dist-types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./configuration";
+export * from "./eventstream-payload-handler-provider";
+export * from "./plugin";
+export * from "./websocket-fetch-handler";

package/dist-types/middleware-session-id.d.ts

@@ -0,0 +1,10 @@
+import { InitializeHandlerOptions, InitializeMiddleware } from "@aws-sdk/types";
+/**
+ * Most WebSocket operations contains `SessionId` parameter in both input and
+ * output, with the same value. This middleware populates the `SessionId`
+ * parameter from request to the response. This is necessary because in
+ * WebSocket, the SDK cannot access any parameters other than the response
+ * stream. So we fake response parameter.
+ */
+export declare const injectSessionIdMiddleware: () => InitializeMiddleware<any, any>;
+export declare const injectSessionIdMiddlewareOptions: InitializeHandlerOptions;

package/dist-types/middleware-websocket-endpoint.d.ts

@@ -0,0 +1,13 @@
+import { BuildMiddleware, RelativeMiddlewareOptions, RequestHandler } from "@aws-sdk/types";
+/**
+ * Middleware that modify the request to from http to WebSocket
+ * This middleware can only be applied to commands that supports bi-directional event streaming via WebSocket.
+ * Example of headerPrefix is "x-amz-rekognition-streaming-liveness-*" prefix exists for all rekognition streaming
+ * websocket API's headers. The common prefix are to be removed when moving them from headers to querystring.
+ */
+export declare const websocketEndpointMiddleware: (config: {
+    requestHandler: RequestHandler<any, any>;
+}, options: {
+    headerPrefix: string;
+}) => BuildMiddleware<any, any>;
+export declare const websocketEndpointMiddlewareOptions: RelativeMiddlewareOptions;

package/dist-types/plugin.d.ts

@@ -0,0 +1,8 @@
+import { Pluggable, RequestHandler } from "@aws-sdk/types";
+interface WebSocketResolvedConfig {
+    requestHandler: RequestHandler<any, any>;
+}
+export declare const getWebSocketPlugin: (config: WebSocketResolvedConfig, options: {
+    headerPrefix: string;
+}) => Pluggable<any, any>;
+export {};

package/dist-types/ts3.4/EventStreamPayloadHandler.d.ts

@@ -0,0 +1,29 @@
+import {
+  Decoder,
+  Encoder,
+  EventSigner,
+  EventStreamPayloadHandler as IEventStreamPayloadHandler,
+  FinalizeHandler,
+  FinalizeHandlerArguments,
+  FinalizeHandlerOutput,
+  HandlerExecutionContext,
+  MetadataBearer,
+  Provider,
+} from "@aws-sdk/types";
+export interface EventStreamPayloadHandlerOptions {
+  eventSigner: Provider<EventSigner>;
+  utf8Encoder: Encoder;
+  utf8Decoder: Decoder;
+}
+export declare class EventStreamPayloadHandler
+  implements IEventStreamPayloadHandler
+{
+  private readonly eventSigner;
+  private readonly eventStreamCodec;
+  constructor(options: EventStreamPayloadHandlerOptions);
+  handle<T extends MetadataBearer>(
+    next: FinalizeHandler<any, T>,
+    args: FinalizeHandlerArguments<any>,
+    context?: HandlerExecutionContext
+  ): Promise<FinalizeHandlerOutput<T>>;
+}

package/dist-types/ts3.4/WebsocketSignatureV4.d.ts

@@ -0,0 +1,22 @@
+import { SignatureV4 as BaseSignatureV4 } from "@aws-sdk/signature-v4";
+import {
+  HttpRequest as IHttpRequest,
+  RequestPresigner,
+  RequestPresigningArguments,
+  RequestSigner,
+  RequestSigningArguments,
+} from "@aws-sdk/types";
+export declare class WebsocketSignatureV4
+  implements RequestSigner, RequestPresigner
+{
+  private readonly signer;
+  constructor(options: { signer: BaseSignatureV4 });
+  presign(
+    originalRequest: IHttpRequest,
+    options?: RequestPresigningArguments
+  ): Promise<IHttpRequest>;
+  sign(
+    toSign: IHttpRequest,
+    options?: RequestSigningArguments
+  ): Promise<IHttpRequest>;
+}

package/dist-types/ts3.4/configuration.d.ts

@@ -0,0 +1,14 @@
+import { AuthScheme, RequestHandler, RequestSigner } from "@aws-sdk/types";
+export interface WebSocketInputConfig {}
+interface PreviouslyResolved {
+  signer: (authScheme: AuthScheme) => Promise<RequestSigner>;
+  requestHandler: RequestHandler<any, any>;
+}
+export interface WebSocketResolvedConfig {
+  signer: (authScheme: AuthScheme) => Promise<RequestSigner>;
+  requestHandler: RequestHandler<any, any>;
+}
+export declare const resolveWebSocketConfig: <T>(
+  input: T & WebSocketInputConfig & PreviouslyResolved
+) => T & WebSocketResolvedConfig;
+export {};

package/dist-types/ts3.4/eventstream-payload-handler-provider.d.ts

@@ -0,0 +1,2 @@
+import { EventStreamPayloadHandlerProvider } from "@aws-sdk/types";
+export declare const eventStreamPayloadHandlerProvider: EventStreamPayloadHandlerProvider;

package/dist-types/ts3.4/get-event-signing-stream.d.ts

@@ -0,0 +1,7 @@
+import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
+import { EventSigner } from "@aws-sdk/types";
+export declare const getEventSigningTransformStream: (
+  initialSignature: string,
+  eventSigner: EventSigner,
+  eventStreamCodec: EventStreamCodec
+) => TransformStream<Uint8Array, Uint8Array>;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./configuration";
+export * from "./eventstream-payload-handler-provider";
+export * from "./plugin";
+export * from "./websocket-fetch-handler";

package/dist-types/ts3.4/middleware-session-id.d.ts

@@ -0,0 +1,6 @@
+import { InitializeHandlerOptions, InitializeMiddleware } from "@aws-sdk/types";
+export declare const injectSessionIdMiddleware: () => InitializeMiddleware<
+  any,
+  any
+>;
+export declare const injectSessionIdMiddlewareOptions: InitializeHandlerOptions;

package/dist-types/ts3.4/middleware-websocket-endpoint.d.ts

@@ -0,0 +1,14 @@
+import {
+  BuildMiddleware,
+  RelativeMiddlewareOptions,
+  RequestHandler,
+} from "@aws-sdk/types";
+export declare const websocketEndpointMiddleware: (
+  config: {
+    requestHandler: RequestHandler<any, any>;
+  },
+  options: {
+    headerPrefix: string;
+  }
+) => BuildMiddleware<any, any>;
+export declare const websocketEndpointMiddlewareOptions: RelativeMiddlewareOptions;

package/dist-types/ts3.4/plugin.d.ts

@@ -0,0 +1,11 @@
+import { Pluggable, RequestHandler } from "@aws-sdk/types";
+interface WebSocketResolvedConfig {
+  requestHandler: RequestHandler<any, any>;
+}
+export declare const getWebSocketPlugin: (
+  config: WebSocketResolvedConfig,
+  options: {
+    headerPrefix: string;
+  }
+) => Pluggable<any, any>;
+export {};

package/dist-types/ts3.4/utils.d.ts

@@ -0,0 +1,2 @@
+import { HttpRequest } from "@aws-sdk/types";
+export declare const isWebSocketRequest: (request: HttpRequest) => boolean;

package/dist-types/ts3.4/websocket-fetch-handler.d.ts

@@ -0,0 +1,28 @@
+import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
+import {
+  Provider,
+  RequestHandler,
+  RequestHandlerMetadata,
+} from "@aws-sdk/types";
+export interface WebSocketFetchHandlerOptions {
+  connectionTimeout?: number;
+}
+export declare class WebSocketFetchHandler {
+  readonly metadata: RequestHandlerMetadata;
+  private readonly configPromise;
+  private readonly httpHandler;
+  private readonly sockets;
+  constructor(
+    options?:
+      | WebSocketFetchHandlerOptions
+      | Provider<WebSocketFetchHandlerOptions>,
+    httpHandler?: RequestHandler<any, any>
+  );
+  destroy(): void;
+  handle(request: HttpRequest): Promise<{
+    response: HttpResponse;
+  }>;
+  private removeNotUsableSockets;
+  private waitForReady;
+  private connect;
+}

package/dist-types/utils.d.ts

@@ -0,0 +1,2 @@
+import { HttpRequest } from "@aws-sdk/types";
+export declare const isWebSocketRequest: (request: HttpRequest) => boolean;

package/dist-types/websocket-fetch-handler.d.ts

@@ -0,0 +1,36 @@
+import { HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
+import { Provider, RequestHandler, RequestHandlerMetadata } from "@aws-sdk/types";
+export interface WebSocketFetchHandlerOptions {
+    /**
+     * The maximum time in milliseconds that the connection phase of a request
+     * may take before the connection attempt is abandoned.
+     */
+    connectionTimeout?: number;
+}
+/**
+ * Base handler for websocket requests and HTTP request. By default, the request input and output
+ * body will be in a ReadableStream, because of interface consistency among middleware.
+ * If ReadableStream is not available, like in React-Native, the response body
+ * will be an async iterable.
+ */
+export declare class WebSocketFetchHandler {
+    readonly metadata: RequestHandlerMetadata;
+    private readonly configPromise;
+    private readonly httpHandler;
+    private readonly sockets;
+    constructor(options?: WebSocketFetchHandlerOptions | Provider<WebSocketFetchHandlerOptions>, httpHandler?: RequestHandler<any, any>);
+    /**
+     * Destroys the WebSocketHandler.
+     * Closes all sockets from the socket pool.
+     */
+    destroy(): void;
+    handle(request: HttpRequest): Promise<{
+        response: HttpResponse;
+    }>;
+    /**
+     * Removes all closing/closed sockets from the socket pool for URL.
+     */
+    private removeNotUsableSockets;
+    private waitForReady;
+    private connect;
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@aws-sdk/middleware-websocket",
+  "version": "3.305.0",
+  "main": "./dist-cjs/index.js",
+  "module": "./dist-es/index.js",
+  "types": "./dist-types/index.d.ts",
+  "scripts": {
+    "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:es": "tsc -p tsconfig.es.json",
+    "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "test": "jest"
+  },
+  "author": {
+    "name": "AWS SDK for JavaScript Team",
+    "url": "https://aws.amazon.com/javascript/"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@aws-sdk/eventstream-serde-browser": "3.303.0",
+    "@aws-sdk/fetch-http-handler": "3.303.0",
+    "@aws-sdk/middleware-signing": "3.303.0",
+    "@aws-sdk/protocol-http": "3.303.0",
+    "@aws-sdk/signature-v4": "3.303.0",
+    "@aws-sdk/types": "3.303.0",
+    "@aws-sdk/util-format-url": "3.303.0",
+    "@aws-sdk/util-hex-encoding": "3.295.0",
+    "tslib": "^2.5.0"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "1.0.1",
+    "@types/uuid": "^8.3.0",
+    "concurrently": "7.0.0",
+    "downlevel-dts": "0.7.0",
+    "jest-websocket-mock": "^2.0.2",
+    "mock-socket": "9.1.5",
+    "rimraf": "3.0.2",
+    "typedoc": "0.23.23",
+    "typescript": "~4.9.5",
+    "web-streams-polyfill": "3.2.1"
+  },
+  "engines": {
+    "node": ">= 14.0.0"
+  },
+  "typesVersions": {
+    "<4.0": {
+      "dist-types/*": [
+        "dist-types/ts3.4/*"
+      ]
+    }
+  },
+  "files": [
+    "dist-*"
+  ],
+  "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/middleware-websocket",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/aws-sdk-js-v3.git",
+    "directory": "packages/middleware-websocket"
+  },
+  "typedoc": {
+    "entryPoint": "src/index.ts"
+  }
+}