@znight/websocket 0.0.0-stage → 0.6.0

package/dist/index.d.mts

@@ -0,0 +1,501 @@
+import { a as TransportSocket, i as TransportSettings, n as SendStatus, o as WebSocketTransport, r as SocketEvents, t as AcceptInit } from "./transport-xnJqvB93.mjs";
+import { A as TokenBucket, C as encodeErrorEvent, D as isFailure, E as encodeReply, O as isMessageId, S as decodeFrame, T as encodeEvent, _ as InboundMessage, a as WsCloseInfo, b as WireError, c as WsConnection, d as Broadcast, f as ChannelMember, g as InboundFailure, h as EVENT_NAME, i as WsServer, k as jsonCodec, l as WsSendResult, m as RoomRegistry, n as GatewayRef, o as WsCloseInitiator, p as MemberRef, r as ServedGateway, s as WsClosedError, t as GatewayChannel, u as WsStats, v as MessageId, w as encodeErrorReply, x as WsCodec, y as OutboundMessage } from "./server-CI_Bh9o1.mjs";
+import { Plugin, PluginContext, PluginOptions, PluginRootsContext, ProviderKey, Token, TypedToken, ZnightError } from "@znight/core";
+import { ByteSize, HttpContext, InferSchemaOutput, InjectResponse, PluginHttpUpgrades, PluginHttpUpgradesContext, PluginUpgrades, StandardSchemaV1 } from "@znight/http";
+/** How a memory connection closed. */
+interface MemoryCloseInfo {
+  readonly code: number;
+  readonly reason: string;
+}
+/**
+ * The client side of an in-memory connection: pass it as the `peer` of a memory upgrade
+ * (`{ kind: 'memory', peer: client }`), then read `received` and send frames.
+ */
+export declare class MemoryClient {
+  #private;
+  /** Frames received from the server, in order. */
+  readonly received: (string | Uint8Array)[];
+  /** Called for each frame received from the server. */
+  onmessage: ((frame: string | Uint8Array) => void) | undefined;
+  /** Called once when the connection closes. */
+  onclose: ((info: MemoryCloseInfo) => void) | undefined;
+  /** The subprotocol the server selected, `''` when none. */
+  get protocol(): string;
+  /** How the connection closed, `undefined` while open. */
+  get closed(): MemoryCloseInfo | undefined;
+  /** Whether the server accepted the connection. */
+  get open(): boolean;
+  /** Sends a frame to the server (a string is a text frame). */
+  send(frame: string | Uint8Array): void;
+  /** Closes the connection from the client side. */
+  close(code?: number, reason?: string): void;
+  /** @internal Bound by the memory transport. */
+  attach(server: MemorySocket, protocol: string): void;
+  /** @internal */
+  deliver(frame: string | Uint8Array): void;
+  /** @internal */
+  closedWith(info: MemoryCloseInfo): void;
+}
+/** The server side of an in-memory connection. */
+declare class MemorySocket implements TransportSocket {
+  #private;
+  readonly bufferedAmount = 0;
+  readonly extensions = "";
+  constructor(client: MemoryClient, events: SocketEvents);
+  send(frame: string | Uint8Array, _binary: boolean): SendStatus;
+  ping(): void;
+  pause(): boolean;
+  resume(): void;
+  close(code: number, reason: string): void;
+  terminate(): void;
+  receive(frame: string | Uint8Array): void;
+  closeFromPeer(code: number, reason: string): void;
+}
+/** The in-memory transport: completes `{ kind: 'memory', peer }` upgrades whose peer is a {@link MemoryClient}. */
+export declare function memoryTransport(): WebSocketTransport;
+/** Options of `WebSocketPlugin.connect()`. */
+interface WsConnectOptions {
+  /** Query parameters appended to the path. */
+  readonly query?: Readonly<Record<string, string | readonly string[]>>;
+  /** Request headers of the handshake. */
+  readonly headers?: Readonly<Record<string, string>>;
+  /** Offered subprotocols (`sec-websocket-protocol`), in preference order. */
+  readonly protocols?: readonly string[];
+  /** The `origin` header (a browser's). Default: none, like a non-browser client. */
+  readonly origin?: string;
+  /** Cookies of the handshake. */
+  readonly cookies?: Readonly<Record<string, string>>;
+}
+/** Options of the waiting methods of {@link WsClient}. */
+interface WsWaitOptions {
+  /** Default: 1 000 ms (`request()`: 5 000 ms). */
+  readonly timeoutMs?: number;
+}
+/** A refused handshake: the HTTP response the server answered. */
+export declare class WsHandshakeError extends Error {
+  #private;
+  readonly status: number;
+  readonly headers: Readonly<Record<string, string | string[]>>;
+  readonly body: string;
+  constructor(response: InjectResponse);
+  /** The body parsed as JSON. */
+  json<T = unknown>(): T;
+}
+/** The failure reply of a request (`{ id, error }`). */
+export declare class WsRequestError extends Error {
+  readonly code: string;
+  readonly details: unknown;
+  constructor(event: string, error: {
+    readonly code?: unknown;
+    readonly message?: unknown;
+    readonly details?: unknown;
+  });
+}
+/** An in-memory WebSocket client (`WebSocketPlugin.connect()`, `TestApp.connect()`). */
+export declare class WsClient implements AsyncDisposable {
+  #private;
+  /** @internal Created by `WebSocketPlugin.connect()` once the handshake succeeded. */
+  constructor(peer: MemoryClient);
+  /** The negotiated subprotocol, `''` when none. */
+  get protocol(): string;
+  /** Every frame received, in order: JSON objects decoded, other text frames as strings, binary frames as bytes. */
+  get frames(): readonly unknown[];
+  /** Resolves once the connection closed (by either side). */
+  get closed(): Promise<MemoryCloseInfo>;
+  /** Sends an event without id (fire and forget). */
+  send(event: string, data?: unknown): void;
+  /** Sends a request and resolves with the `data` of its reply; rejects with {@link WsRequestError}. */
+  request<T = unknown>(event: string, data?: unknown, options?: WsWaitOptions): Promise<T>;
+  /** The `data` of the oldest server event (matching `event`) not taken yet. */
+  next<T = unknown>(event?: string, options?: WsWaitOptions): Promise<T>;
+  /** Sends a frame as is (a string is a text frame). */
+  sendRaw(frame: string | Uint8Array): void;
+  /** The oldest frame not taken by `nextRaw()` yet, as received. */
+  nextRaw(options?: WsWaitOptions): Promise<string | Uint8Array>;
+  /** Closes the connection and resolves with how it closed. */
+  close(code?: number, reason?: string): Promise<MemoryCloseInfo>;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+/** Exceptions of WebSocket handlers and their wire codes (RFC 0003 §5.3, §5.8). */
+/** Built-in error codes of the wire protocol. */
+export declare const WsErrorCode: {
+  readonly BadFrame: "BAD_FRAME";
+  readonly UnsupportedFrame: "UNSUPPORTED_FRAME";
+  readonly BadRequest: "BAD_REQUEST";
+  readonly Unauthorized: "UNAUTHORIZED";
+  readonly Forbidden: "FORBIDDEN";
+  readonly NotFound: "NOT_FOUND";
+  readonly Conflict: "CONFLICT";
+  readonly Unprocessable: "UNPROCESSABLE";
+  readonly RateLimited: "RATE_LIMITED";
+  readonly UnknownEvent: "UNKNOWN_EVENT";
+  readonly Timeout: "TIMEOUT";
+  readonly Internal: "INTERNAL";
+};
+/** Close codes used by the runtime (RFC 0003 §5.8, normative). */
+export declare const WsCloseCode: {
+  readonly Normal: 1000;
+  readonly GoingAway: 1001;
+  readonly PolicyViolation: 1008;
+  readonly MessageTooBig: 1009;
+  readonly InternalError: 1011;
+  readonly TryAgainLater: 1013;
+};
+/** Options of {@link WsException}. */
+interface WsExceptionOptions {
+  /** Close the connection with this code after replying. */
+  readonly close?: number;
+  readonly cause?: unknown;
+}
+/**
+ * An error a handler or a message guard throws to answer the client: a reply with an `id`, an
+ * `$error` event otherwise, then a close when `close` is set.
+ *
+ * ```ts
+ * throw new WsException('FORBIDDEN', 'Join the room first')
+ * ```
+ */
+export declare class WsException extends Error {
+  readonly code: string;
+  readonly details: unknown;
+  readonly close: number | undefined;
+  constructor(code: string, message?: string, details?: unknown, options?: WsExceptionOptions);
+}
+/** One issue of a {@link WsValidationException}. */
+interface WsValidationIssue {
+  readonly path: string;
+  readonly message: string;
+}
+/** A payload failed its schema: `BAD_REQUEST` with `details: [{ path, message }]`. */
+export declare class WsValidationException extends WsException {
+  readonly issues: readonly WsValidationIssue[];
+  constructor(issues: readonly WsValidationIssue[], message?: string);
+}
+/**
+ * The wire code of an HTTP status thrown by a service (`HttpException`): the table of RFC 0003
+ * §5.8, `INTERNAL` for 5xx and unknown statuses.
+ */
+export declare function codeOfStatus(status: number): string;
+/** What handlers (`@Ctx()`) and message guards see of one message. */
+interface WsMessageContext {
+  readonly connection: WsConnection;
+  /** `undefined` on raw gateways. */
+  readonly event: string | undefined;
+  readonly id: string | number | undefined;
+  /** The decoded `data` (events) or the frame (raw). */
+  readonly data: unknown;
+  readonly binary: boolean;
+  readonly bytes: number;
+  /** `performance.now()` when the message was received. */
+  readonly receivedAt: number;
+  /** Aborted on timeout or when the connection closes. */
+  readonly signal: AbortSignal;
+  /** Per message: guards to handler. */
+  readonly state: Map<string | symbol, unknown>;
+  readonly route: {
+    readonly path: string;
+    readonly gateway: Token;
+    readonly handler: string | undefined;
+    readonly event: string | undefined;
+    readonly meta: Readonly<Record<string, unknown>>;
+  };
+}
+/** A guard run before each message handler: `false` answers `FORBIDDEN`. */
+interface WsGuard {
+  canHandle(ctx: WsMessageContext): boolean | Promise<boolean>;
+}
+/**
+ * Maps an error thrown by a message handler or guard to the {@link WsException} answered to the
+ * client (plugin option `exceptionMappers`, run in order before the built-in mapping). `undefined`:
+ * not handled, the next mapper or the built-in mapping applies.
+ */
+interface WsExceptionMapper {
+  map(error: unknown, ctx: WsMessageContext): WsException | undefined | Promise<WsException | undefined>;
+}
+/** The gateways of the application, sorted by token. */
+interface WebSocketMetadata {
+  readonly gateways: readonly GatewayDefinition[];
+  /**
+   * Route decorator groups the runtime needs (required, holding several keys, or named differently
+   * from their key), as `metadata.extensions.http.groups`. Absent when no group needs it.
+   */
+  readonly groups?: Readonly<Record<string, {
+    readonly keys: readonly string[];
+    readonly required: boolean;
+  }>>;
+}
+/** One `@Gateway` class. Optional fields are omitted when absent. */
+interface GatewayDefinition {
+  readonly token: Token;
+  /** The normalized `@Gateway` path, without the `HttpPlugin` prefix. */
+  readonly path: string;
+  readonly protocol: "events" | "raw";
+  readonly protocols?: readonly string[];
+  /** Bytes. */
+  readonly maxPayload?: number;
+  readonly concurrency?: number;
+  readonly rateLimit?: {
+    readonly messages: number;
+    readonly intervalMs: number;
+    readonly onLimit: "reject" | "close";
+  };
+  /** `limit` in bytes. */
+  readonly backpressure?: {
+    readonly limit?: number;
+    readonly onLimit?: "close" | "drop";
+  };
+  /** Route decorators of the class: handshake and messages. */
+  readonly meta: Readonly<Record<string, unknown>>;
+  /** `@UseHandshakeGuard`, in order. */
+  readonly handshakeGuards: readonly Token[];
+  /** `@UseMessageGuard` on the class, in order. */
+  readonly messageGuards: readonly Token[];
+  readonly onConnect?: WsLifecycleDefinition;
+  readonly onDisconnect?: WsLifecycleDefinition;
+  /** Declaration order, bases first. */
+  readonly handlers: readonly WsHandlerDefinition[];
+}
+/** `@OnConnect` or `@OnDisconnect`. */
+interface WsLifecycleDefinition {
+  readonly method: string;
+  readonly invoke: (gateway: any, connection: WsConnection) => unknown;
+}
+/** A parameter of a handler (informational). */
+interface WsParamDefinition {
+  readonly index: number;
+  readonly source: "payload" | "connection" | "context";
+  readonly schema?: boolean;
+  readonly optional?: boolean;
+}
+/** One `@OnMessage` handler. */
+interface WsHandlerDefinition {
+  readonly method: string;
+  /** Absent: the default handler. */
+  readonly event?: string;
+  /** Route decorators of the method, merged over the gateway's at boot (nearest wins). */
+  readonly meta: Readonly<Record<string, unknown>>;
+  /** `@UseMessageGuard` on the method. */
+  readonly guards: readonly Token[];
+  readonly params: readonly WsParamDefinition[];
+  readonly invoke: (gateway: any, ctx: WsMessageContext) => unknown;
+}
+declare module "@znight/core" {
+  interface ZnightExtensionsMetadata {
+    readonly websocket?: WebSocketMetadata;
+  }
+}
+/** Options of `@Gateway` (RFC 0003 §5.2), all static: the compiler reads them. */
+interface GatewayOptions {
+  /** HTTP path grammar (`/chat`, `/docs/:docId`, `/feeds/*`). Default: `'/'`. */
+  readonly path?: string;
+  /** `'request'`: one gateway instance per connection. Default: `'singleton'`. */
+  readonly scope?: "singleton" | "request";
+  /** `'events'` (envelope, routing by event) or `'raw'` (one default handler). Default: `'events'`. */
+  readonly protocol?: "events" | "raw";
+  /** Accepted subprotocols, in preference order: a client offering none of them is refused (400). */
+  readonly protocols?: readonly string[];
+  /** Largest inbound message (`'64kb'` or bytes). Default: the plugin `maxPayload`. */
+  readonly maxPayload?: string | number;
+  /** Messages of one connection handled in parallel. Default: `1` (keeps the order). */
+  readonly concurrency?: number;
+  /** A token bucket per connection. */
+  readonly rateLimit?: RateLimitOptions;
+  /** Outbound buffer limit and what to do above it. Default: the plugin `backpressure`. */
+  readonly backpressure?: BackpressureOptions;
+}
+/** `@Gateway({ rateLimit })`. */
+interface RateLimitOptions {
+  readonly messages: number;
+  readonly intervalMs: number;
+  /** `'reject'` answers `RATE_LIMITED` (default), `'close'` closes with `4429`. */
+  readonly onLimit?: "reject" | "close";
+}
+/** `@Gateway({ backpressure })` and the plugin option. */
+interface BackpressureOptions {
+  /** Buffered outbound bytes above which `onLimit` applies (`'1mb'` or bytes). */
+  readonly limit?: string | number;
+  /** `'close'` closes with `1013` (default), `'drop'` drops the message. */
+  readonly onLimit?: "close" | "drop";
+}
+/** `'same-origin'`, `'*'`, exact origins and anchored `RegExp`s, or a function (RFC 0003 §5.6). */
+type WsOrigins = "same-origin" | "*" | string | RegExp | readonly (string | RegExp)[] | ((origin: string, ctx: HttpContext) => boolean | Promise<boolean>);
+/** A message guard or an exception mapper: a provider class or an instance. */
+type WsProviderRef<T> = (abstract new (...args: never[]) => T) | T;
+/** Options of `WebSocketPlugin.configure()`. */
+interface WebSocketPluginOptions {
+  /** `'auto'` (default): Bun's native transport with `honoAdapter()` on Bun, `ws` otherwise. */
+  readonly transport?: "auto" | WebSocketTransport;
+  /** Allowed `Origin`s of handshakes. Default: `'same-origin'` (and requests without `Origin`). */
+  readonly origins?: WsOrigins;
+  /** Largest inbound message (`'1mb'` or bytes). Default: `'1mb'`. Gateways may lower it. */
+  readonly maxPayload?: ByteSize;
+  /** Open connections per process; above, handshakes get `503`. Default: `Infinity`. */
+  readonly maxConnections?: number;
+  /** Inbound queue per connection before reading pauses. Default: `32`. */
+  readonly maxPendingMessages?: number;
+  /** Outbound buffer per connection. Default: `{ limit: '1mb', onLimit: 'close' }`. */
+  readonly backpressure?: BackpressureOptions;
+  /** Ping interval; `false` disables heartbeats. Default: `{ intervalMs: 30_000 }`. */
+  readonly heartbeat?: {
+    readonly intervalMs: number;
+  } | false;
+  /** Handshakes whose guards have not answered by then get `408`. Default: `10_000`. */
+  readonly handshakeTimeoutMs?: number;
+  /** Per message and per `@OnConnect`: `TIMEOUT`. `Infinity` disables. Default: `30_000`. */
+  readonly handlerTimeoutMs?: number;
+  /** Wait for the client's close frame before terminating. Default: `2_000`. */
+  readonly closeTimeoutMs?: number;
+  /** The codec of `events` gateways. Default: `jsonCodec` (JSON text frames). */
+  readonly codec?: WsCodec;
+  /** Global message guards, run before the gateway's and the handler's. */
+  readonly messageGuards?: readonly WsProviderRef<WsGuard>[];
+  /** Exception mappers of message handlers and guards, in order. */
+  readonly exceptionMappers?: readonly WsProviderRef<WsExceptionMapper>[];
+  /** Send the message of unexpected errors (`INTERNAL`). Default: `false`. */
+  readonly exposeErrors?: boolean;
+  /** Graceful shutdown. Default: `{ code: 1001, reason: 'Server shutting down', timeoutMs: 3_000 }`. */
+  readonly shutdown?: {
+    readonly code?: number;
+    readonly reason?: string;
+    readonly timeoutMs?: number;
+  };
+}
+/** A class decorator marker. */
+type GatewayClassMarker = (target: abstract new (...args: never[]) => unknown) => void;
+/** A method decorator marker. */
+type GatewayMethodMarker = (target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void;
+/** A parameter decorator marker. */
+type GatewayParameterMarker = (target: object, propertyKey: string | symbol | undefined, index: number) => void;
+/** A class or method decorator marker. */
+type GatewayClassOrMethodMarker = (target: object, propertyKey?: string | symbol, descriptor?: unknown) => void;
+/**
+ * A provider whose methods handle the WebSocket connections of `path` (default `/`), joined to the
+ * `HttpPlugin` prefix.
+ *
+ * ```ts
+ * @Gateway({ path: '/chat', protocols: ['chat.v1'] })
+ * export class ChatGateway {}
+ * ```
+ */
+export declare function Gateway(_pathOrOptions?: string | GatewayOptions): GatewayClassMarker;
+/** Runs once the handshake succeeded, before any message. Throwing closes the connection. */
+export declare function OnConnect(): GatewayMethodMarker;
+/**
+ * Handles an event (`events` protocol). Without `event`: the default handler (unknown events, every
+ * message of a `raw` gateway). Repeatable.
+ */
+export declare function OnMessage(_event?: string): GatewayMethodMarker;
+/** Runs once per connection whose `@OnConnect` completed, before rooms are left and the scope closes. */
+export declare function OnDisconnect(): GatewayMethodMarker;
+/** The message `data` (`events`) or the raw frame (`raw`), validated by `schema` (a Standard Schema). */
+export declare function Payload(_schema?: unknown): GatewayParameterMarker;
+/** The `WsConnection` of the message or of the lifecycle method. */
+export declare function Conn(): GatewayParameterMarker;
+/** The `WsMessageContext` (`@OnMessage` handlers only). */
+export declare function Ctx(): GatewayParameterMarker;
+/** Extra HTTP guards (`CanActivate`) of the handshake, after the `HttpPlugin` global guards. */
+export declare function UseHandshakeGuard(..._guards: readonly unknown[]): GatewayClassMarker;
+/** Message guards (`WsGuard`) run before each handler: global, then class, then method. */
+export declare function UseMessageGuard(..._guards: readonly unknown[]): GatewayClassOrMethodMarker;
+/** A served gateway, as listed by {@link WebSocketPlugin.gateways}. */
+interface WsGatewaySummary {
+  /** The path, HTTP prefix included. */
+  readonly path: string;
+  /** Display name of the gateway class. */
+  readonly gateway: string;
+  readonly protocol: "events" | "raw";
+  /** Handled events (`events` gateways), in declaration order. */
+  readonly events: readonly string[];
+}
+/**
+ * The WebSocket plugin: `WebSocketPlugin.configure(options)` (name `websocket`). Requires
+ * `HttpPlugin`: gateways are served on its server and port, whatever the plugin order.
+ *
+ * ```ts
+ * await Application.create({
+ *   metadata: __ZNIGHT_METADATA__,
+ *   plugins: [HttpPlugin.configure({ port: 3000 }), WebSocketPlugin.configure({ maxPayload: '64kb' })],
+ * })
+ * ```
+ */
+export declare class WebSocketPlugin implements Plugin, PluginHttpUpgrades {
+  #private;
+  readonly name = "websocket";
+  /** The `WsServer` of the application (also injectable). */
+  readonly server: WsServer;
+  private constructor();
+  /**
+   * Creates the plugin. `options` may be a function of the container, evaluated once the container
+   * is initialised: `WebSocketPlugin.configure(c => ({ origins: c.get(ServerConfig).webOrigins }))`.
+   */
+  static configure(options?: PluginOptions<WebSocketPluginOptions>): WebSocketPlugin;
+  /** Name of the transport (`ws`, `bun`), `undefined` before `HttpPlugin` collected the upgrade routes. */
+  get transport(): string | undefined;
+  /** The served gateways (after bootstrap). */
+  get gateways(): readonly WsGatewaySummary[];
+  /** Open connections of every gateway. */
+  get connections(): number;
+  /** Totals since the application started. */
+  stats(): WsStats;
+  /**
+   * Providers `TestApp` creates at boot: the classes of the `messageGuards` and `exceptionMappers`
+   * options, and the gateways of the metadata with their guards.
+   */
+  initRoots(context?: PluginRootsContext): readonly ProviderKey[];
+  register(ctx: PluginContext): void;
+  onBootstrap(ctx: PluginContext): void;
+  /**
+   * The `PluginHttpUpgrades` contract of `@znight/http`: one upgrade route per gateway, and the
+   * `Bun.serve()` settings of the Bun transport. Called once by `HttpPlugin.onBootstrap`. No route
+   * (and no transport) without gateways.
+   */
+  httpUpgrades(context: PluginHttpUpgradesContext): PluginUpgrades;
+  onStart(): Promise<void>;
+  /**
+   * The `PluginHttpRoutes` contract: `HttpPlugin` starts draining, whatever the plugin order.
+   * Refuses new handshakes and closes every connection gracefully (see {@link onStop}).
+   */
+  onHttpDrain(): Promise<void>;
+  /**
+   * Refuses handshakes (`503`), closes every connection with `shutdown.code`, waits for close
+   * frames, running handlers and `@OnDisconnect` up to `shutdown.timeoutMs`, then terminates the
+   * rest. Idempotent: the same drain as {@link onHttpDrain}.
+   */
+  onStop(): Promise<void>;
+  onDispose(): Promise<void>;
+  /**
+   * Opens an in-memory connection (tests): the real handshake through the HTTP pipeline (guards,
+   * hooks, origin and subprotocol checks) with an in-memory request, then the in-memory transport.
+   * `path` is the URL path, HTTP prefix included. Rejects with {@link WsHandshakeError} when the
+   * handshake is refused.
+   *
+   * ```ts
+   * await using alice = await plugin.connect('/chat', { protocols: ['chat.v1'] })
+   * expect(await alice.request('room.join', { room: 'general' })).toEqual({ members: 1 })
+   * ```
+   */
+  connect(path: string, options?: WsConnectOptions): Promise<WsClient>;
+}
+/**
+ * Tokens of the values `@znight/websocket` supplies to the container. `WsConnection` is a
+ * request-scoped external: the request scope of a WebSocket handshake lasts as long as its
+ * connection. Inject it in request-scoped providers (`@Gateway({ scope: 'request' })`) or through
+ * `Lazy<WsConnection>`.
+ */
+export declare const WsTokens: {
+  /** The {@link WsServer} of the application (singleton). */
+  readonly Server: TypedToken<WsServer>;
+  /** The {@link WebSocketPlugin} instance (singleton). */
+  readonly Plugin: TypedToken<WebSocketPlugin>;
+  /** The {@link WsConnection} of the current connection (request scope). */
+  readonly Connection: TypedToken<WsConnection>;
+};
+/**
+ * Validates a message payload with a Standard Schema and returns the schema output, synchronously
+ * when the schema is synchronous.
+ *
+ * @throws WsValidationException (`BAD_REQUEST`, `details: [{ path, message }]`) when the payload is invalid.
+ */
+export declare function validatePayload<S extends StandardSchemaV1>(schema: S, value: unknown): InferSchemaOutput<S> | Promise<InferSchemaOutput<S>>;
+export { type AcceptInit, type BackpressureOptions, type Broadcast, type ChannelMember, EVENT_NAME, type GatewayChannel, type GatewayClassMarker, type GatewayClassOrMethodMarker, type GatewayDefinition, type GatewayMethodMarker, type GatewayOptions, type GatewayParameterMarker, type GatewayRef, type InboundFailure, type InboundMessage, type MemberRef, type MemoryCloseInfo, type MessageId, type OutboundMessage, type RateLimitOptions, RoomRegistry, type SendStatus, type ServedGateway, type SocketEvents, TokenBucket, type TransportSettings, type TransportSocket, type WebSocketMetadata, type WebSocketPluginOptions, type WebSocketTransport, type WireError, type WsCloseInfo, type WsCloseInitiator, WsClosedError, type WsCodec, type WsConnectOptions, type WsConnection, type WsExceptionMapper, type WsExceptionOptions, type WsGatewaySummary, type WsGuard, type WsHandlerDefinition, type WsLifecycleDefinition, type WsMessageContext, type WsOrigins, type WsParamDefinition, type WsProviderRef, type WsSendResult, WsServer, type WsStats, type WsValidationIssue, type WsWaitOptions, decodeFrame, encodeErrorEvent, encodeErrorReply, encodeEvent, encodeReply, isFailure, isMessageId, jsonCodec };
+//# sourceMappingURL=index.d.mts.map