crossws 0.1.2 → 0.2.0

package/dist/index.d.cts

@@ -1,115 +1,6 @@
-declare class WebSocketError extends Error {
-    constructor(...args: any[]);
-}
+import { A as AdapterOptions, C as CrossWS } from './shared/crossws.a2e5c71e.cjs';
+export { b as Adapter, f as AdapterHooks, a as Caller, H as Hooks, M as Message, P as Peer, R as ResolveHooks, W as WSError, c as WSRequest, e as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.a2e5c71e.cjs';
 
-declare class WSMessage {
-    readonly rawData: any;
-    readonly isBinary?: boolean | undefined;
-    constructor(rawData: any, isBinary?: boolean | undefined);
-    text(): string;
-    toString(): string;
-}
+declare function createCrossWS(opts?: AdapterOptions): CrossWS;
 
-type ReadyState = 0 | 1 | 2 | 3;
-interface WSRequest {
-    readonly url: string;
-    readonly headers: HeadersInit;
-}
-declare abstract class WSPeer<AdapterContext = any> implements WSRequest {
-    ctx: AdapterContext;
-    _subscriptions: Set<string>;
-    constructor(ctx: AdapterContext);
-    get id(): string | undefined;
-    get url(): string;
-    get headers(): HeadersInit;
-    get readyState(): ReadyState | -1;
-    abstract send(message: any, options?: {
-        compress?: boolean;
-    }): number;
-    publish(topic: string, message: any, options?: {
-        compress?: boolean;
-    }): void;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    toString(): string;
-}
-
-type MaybePromise<T> = T | Promise<T>;
-type _UserHooks = WebSocketHooks & AdapterHooks;
-type UserHooks = Partial<_UserHooks>;
-declare function defineWebSocketHooks<T extends UserHooks = UserHooks>(hooks: T): T;
-type UserHookName = Exclude<keyof _UserHooks, "$">;
-type CatchAllHandler = <Name extends UserHookName>(name: Name, ...args: Parameters<_UserHooks[Name]>) => MaybePromise<void>;
-interface WebSocketHooks {
-    /** Catch-all handler */
-    $: CatchAllHandler;
-    /** Upgrading */
-    upgrade: (req: WSRequest) => MaybePromise<void | {
-        headers?: HeadersInit;
-    }>;
-    /** A message is received */
-    message: (peer: WSPeer, message: WSMessage) => MaybePromise<void>;
-    /** A socket is opened */
-    open: (peer: WSPeer) => MaybePromise<void>;
-    /** A socket is closed */
-    close: (peer: WSPeer, details: {
-        code?: number;
-        reason?: string;
-    }) => MaybePromise<void>;
-    /** An error occurs */
-    error: (peer: WSPeer, error: WebSocketError) => MaybePromise<void>;
-}
-type WSHook<ArgsT extends Array<any> = []> = (peer: WSPeer, ...args: ArgsT) => MaybePromise<void>;
-interface AdapterHooks {
-    "bun:message": WSHook<[ws: any, message: any]>;
-    "bun:open": WSHook<[ws: any]>;
-    "bun:close": WSHook<[ws: any]>;
-    "bun:drain": WSHook<[]>;
-    "bun:error": WSHook<[ws: any, error: any]>;
-    "bun:ping": WSHook<[ws: any, data: any]>;
-    "bun:pong": WSHook<[ws: any, data: any]>;
-    "cloudflare:accept": WSHook<[]>;
-    "cloudflare:message": WSHook<[event: any]>;
-    "cloudflare:error": WSHook<[event: any]>;
-    "cloudflare:close": WSHook<[event: any]>;
-    "deno:open": WSHook<[]>;
-    "deno:message": WSHook<[event: any]>;
-    "deno:close": WSHook<[]>;
-    "deno:error": WSHook<[error: any]>;
-    "node:open": WSHook<[]>;
-    "node:message": WSHook<[data: any, isBinary: boolean]>;
-    "node:close": WSHook<[code: number, reason: Buffer]>;
-    "node:error": WSHook<[error: any]>;
-    "node:ping": WSHook<[data: Buffer]>;
-    "node:pong": WSHook<[data: Buffer]>;
-    "node:unexpected-response": WSHook<[req: any, res: any]>;
-    "node:upgrade": WSHook<[req: any]>;
-    "uws:open": WSHook<[ws: any]>;
-    "uws:message": WSHook<[ws: any, message: any, isBinary: boolean]>;
-    "uws:close": WSHook<[ws: any, code: number, message: any]>;
-    "uws:ping": WSHook<[ws: any, message: any]>;
-    "uws:pong": WSHook<[ws: any, message: any]>;
-    "uws:drain": WSHook<[ws: any]>;
-    "uws:upgrade": WSHook<[res: any, req: any, context: any]>;
-    "uws:subscription": WSHook<[
-        ws: any,
-        topic: any,
-        newCount: number,
-        oldCount: number
-    ]>;
-}
-
-type WebSocketAdapter<RT = any, OT = any> = (hooks: Partial<WebSocketHooks & AdapterHooks>, opts: OT) => RT;
-declare function defineWebSocketAdapter<RT, OT>(factory: WebSocketAdapter<RT, OT>): WebSocketAdapter<RT, OT>;
-
-interface CrossWS extends WebSocketHooks {
-    upgrade: (req: WSRequest) => Promise<{
-        headers: HeadersInit;
-    }>;
-}
-interface CrossWSOptions {
-    resolve?: (info: WSRequest | WSPeer) => UserHooks | Promise<UserHooks>;
-}
-declare function createCrossWS(hooks: UserHooks, options: CrossWSOptions): CrossWS;
-
-export { type AdapterHooks, type CrossWS, type CrossWSOptions, type UserHooks, WSMessage, WSPeer, type WSRequest, type WebSocketAdapter, WebSocketError, type WebSocketHooks, type _UserHooks, createCrossWS, defineWebSocketAdapter, defineWebSocketHooks };
+export { AdapterOptions, CrossWS, createCrossWS };

package/dist/index.d.mts

@@ -1,115 +1,6 @@
-declare class WebSocketError extends Error {
-    constructor(...args: any[]);
-}
+import { A as AdapterOptions, C as CrossWS } from './shared/crossws.a2e5c71e.mjs';
+export { b as Adapter, f as AdapterHooks, a as Caller, H as Hooks, M as Message, P as Peer, R as ResolveHooks, W as WSError, c as WSRequest, e as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.a2e5c71e.mjs';
 
-declare class WSMessage {
-    readonly rawData: any;
-    readonly isBinary?: boolean | undefined;
-    constructor(rawData: any, isBinary?: boolean | undefined);
-    text(): string;
-    toString(): string;
-}
+declare function createCrossWS(opts?: AdapterOptions): CrossWS;
 
-type ReadyState = 0 | 1 | 2 | 3;
-interface WSRequest {
-    readonly url: string;
-    readonly headers: HeadersInit;
-}
-declare abstract class WSPeer<AdapterContext = any> implements WSRequest {
-    ctx: AdapterContext;
-    _subscriptions: Set<string>;
-    constructor(ctx: AdapterContext);
-    get id(): string | undefined;
-    get url(): string;
-    get headers(): HeadersInit;
-    get readyState(): ReadyState | -1;
-    abstract send(message: any, options?: {
-        compress?: boolean;
-    }): number;
-    publish(topic: string, message: any, options?: {
-        compress?: boolean;
-    }): void;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    toString(): string;
-}
-
-type MaybePromise<T> = T | Promise<T>;
-type _UserHooks = WebSocketHooks & AdapterHooks;
-type UserHooks = Partial<_UserHooks>;
-declare function defineWebSocketHooks<T extends UserHooks = UserHooks>(hooks: T): T;
-type UserHookName = Exclude<keyof _UserHooks, "$">;
-type CatchAllHandler = <Name extends UserHookName>(name: Name, ...args: Parameters<_UserHooks[Name]>) => MaybePromise<void>;
-interface WebSocketHooks {
-    /** Catch-all handler */
-    $: CatchAllHandler;
-    /** Upgrading */
-    upgrade: (req: WSRequest) => MaybePromise<void | {
-        headers?: HeadersInit;
-    }>;
-    /** A message is received */
-    message: (peer: WSPeer, message: WSMessage) => MaybePromise<void>;
-    /** A socket is opened */
-    open: (peer: WSPeer) => MaybePromise<void>;
-    /** A socket is closed */
-    close: (peer: WSPeer, details: {
-        code?: number;
-        reason?: string;
-    }) => MaybePromise<void>;
-    /** An error occurs */
-    error: (peer: WSPeer, error: WebSocketError) => MaybePromise<void>;
-}
-type WSHook<ArgsT extends Array<any> = []> = (peer: WSPeer, ...args: ArgsT) => MaybePromise<void>;
-interface AdapterHooks {
-    "bun:message": WSHook<[ws: any, message: any]>;
-    "bun:open": WSHook<[ws: any]>;
-    "bun:close": WSHook<[ws: any]>;
-    "bun:drain": WSHook<[]>;
-    "bun:error": WSHook<[ws: any, error: any]>;
-    "bun:ping": WSHook<[ws: any, data: any]>;
-    "bun:pong": WSHook<[ws: any, data: any]>;
-    "cloudflare:accept": WSHook<[]>;
-    "cloudflare:message": WSHook<[event: any]>;
-    "cloudflare:error": WSHook<[event: any]>;
-    "cloudflare:close": WSHook<[event: any]>;
-    "deno:open": WSHook<[]>;
-    "deno:message": WSHook<[event: any]>;
-    "deno:close": WSHook<[]>;
-    "deno:error": WSHook<[error: any]>;
-    "node:open": WSHook<[]>;
-    "node:message": WSHook<[data: any, isBinary: boolean]>;
-    "node:close": WSHook<[code: number, reason: Buffer]>;
-    "node:error": WSHook<[error: any]>;
-    "node:ping": WSHook<[data: Buffer]>;
-    "node:pong": WSHook<[data: Buffer]>;
-    "node:unexpected-response": WSHook<[req: any, res: any]>;
-    "node:upgrade": WSHook<[req: any]>;
-    "uws:open": WSHook<[ws: any]>;
-    "uws:message": WSHook<[ws: any, message: any, isBinary: boolean]>;
-    "uws:close": WSHook<[ws: any, code: number, message: any]>;
-    "uws:ping": WSHook<[ws: any, message: any]>;
-    "uws:pong": WSHook<[ws: any, message: any]>;
-    "uws:drain": WSHook<[ws: any]>;
-    "uws:upgrade": WSHook<[res: any, req: any, context: any]>;
-    "uws:subscription": WSHook<[
-        ws: any,
-        topic: any,
-        newCount: number,
-        oldCount: number
-    ]>;
-}
-
-type WebSocketAdapter<RT = any, OT = any> = (hooks: Partial<WebSocketHooks & AdapterHooks>, opts: OT) => RT;
-declare function defineWebSocketAdapter<RT, OT>(factory: WebSocketAdapter<RT, OT>): WebSocketAdapter<RT, OT>;
-
-interface CrossWS extends WebSocketHooks {
-    upgrade: (req: WSRequest) => Promise<{
-        headers: HeadersInit;
-    }>;
-}
-interface CrossWSOptions {
-    resolve?: (info: WSRequest | WSPeer) => UserHooks | Promise<UserHooks>;
-}
-declare function createCrossWS(hooks: UserHooks, options: CrossWSOptions): CrossWS;
-
-export { type AdapterHooks, type CrossWS, type CrossWSOptions, type UserHooks, WSMessage, WSPeer, type WSRequest, type WebSocketAdapter, WebSocketError, type WebSocketHooks, type _UserHooks, createCrossWS, defineWebSocketAdapter, defineWebSocketHooks };
+export { AdapterOptions, CrossWS, createCrossWS };

package/dist/index.d.ts

@@ -1,115 +1,6 @@
-declare class WebSocketError extends Error {
-    constructor(...args: any[]);
-}
+import { A as AdapterOptions, C as CrossWS } from './shared/crossws.a2e5c71e.js';
+export { b as Adapter, f as AdapterHooks, a as Caller, H as Hooks, M as Message, P as Peer, R as ResolveHooks, W as WSError, c as WSRequest, e as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.a2e5c71e.js';
 
-declare class WSMessage {
-    readonly rawData: any;
-    readonly isBinary?: boolean | undefined;
-    constructor(rawData: any, isBinary?: boolean | undefined);
-    text(): string;
-    toString(): string;
-}
+declare function createCrossWS(opts?: AdapterOptions): CrossWS;
 
-type ReadyState = 0 | 1 | 2 | 3;
-interface WSRequest {
-    readonly url: string;
-    readonly headers: HeadersInit;
-}
-declare abstract class WSPeer<AdapterContext = any> implements WSRequest {
-    ctx: AdapterContext;
-    _subscriptions: Set<string>;
-    constructor(ctx: AdapterContext);
-    get id(): string | undefined;
-    get url(): string;
-    get headers(): HeadersInit;
-    get readyState(): ReadyState | -1;
-    abstract send(message: any, options?: {
-        compress?: boolean;
-    }): number;
-    publish(topic: string, message: any, options?: {
-        compress?: boolean;
-    }): void;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    toString(): string;
-}
-
-type MaybePromise<T> = T | Promise<T>;
-type _UserHooks = WebSocketHooks & AdapterHooks;
-type UserHooks = Partial<_UserHooks>;
-declare function defineWebSocketHooks<T extends UserHooks = UserHooks>(hooks: T): T;
-type UserHookName = Exclude<keyof _UserHooks, "$">;
-type CatchAllHandler = <Name extends UserHookName>(name: Name, ...args: Parameters<_UserHooks[Name]>) => MaybePromise<void>;
-interface WebSocketHooks {
-    /** Catch-all handler */
-    $: CatchAllHandler;
-    /** Upgrading */
-    upgrade: (req: WSRequest) => MaybePromise<void | {
-        headers?: HeadersInit;
-    }>;
-    /** A message is received */
-    message: (peer: WSPeer, message: WSMessage) => MaybePromise<void>;
-    /** A socket is opened */
-    open: (peer: WSPeer) => MaybePromise<void>;
-    /** A socket is closed */
-    close: (peer: WSPeer, details: {
-        code?: number;
-        reason?: string;
-    }) => MaybePromise<void>;
-    /** An error occurs */
-    error: (peer: WSPeer, error: WebSocketError) => MaybePromise<void>;
-}
-type WSHook<ArgsT extends Array<any> = []> = (peer: WSPeer, ...args: ArgsT) => MaybePromise<void>;
-interface AdapterHooks {
-    "bun:message": WSHook<[ws: any, message: any]>;
-    "bun:open": WSHook<[ws: any]>;
-    "bun:close": WSHook<[ws: any]>;
-    "bun:drain": WSHook<[]>;
-    "bun:error": WSHook<[ws: any, error: any]>;
-    "bun:ping": WSHook<[ws: any, data: any]>;
-    "bun:pong": WSHook<[ws: any, data: any]>;
-    "cloudflare:accept": WSHook<[]>;
-    "cloudflare:message": WSHook<[event: any]>;
-    "cloudflare:error": WSHook<[event: any]>;
-    "cloudflare:close": WSHook<[event: any]>;
-    "deno:open": WSHook<[]>;
-    "deno:message": WSHook<[event: any]>;
-    "deno:close": WSHook<[]>;
-    "deno:error": WSHook<[error: any]>;
-    "node:open": WSHook<[]>;
-    "node:message": WSHook<[data: any, isBinary: boolean]>;
-    "node:close": WSHook<[code: number, reason: Buffer]>;
-    "node:error": WSHook<[error: any]>;
-    "node:ping": WSHook<[data: Buffer]>;
-    "node:pong": WSHook<[data: Buffer]>;
-    "node:unexpected-response": WSHook<[req: any, res: any]>;
-    "node:upgrade": WSHook<[req: any]>;
-    "uws:open": WSHook<[ws: any]>;
-    "uws:message": WSHook<[ws: any, message: any, isBinary: boolean]>;
-    "uws:close": WSHook<[ws: any, code: number, message: any]>;
-    "uws:ping": WSHook<[ws: any, message: any]>;
-    "uws:pong": WSHook<[ws: any, message: any]>;
-    "uws:drain": WSHook<[ws: any]>;
-    "uws:upgrade": WSHook<[res: any, req: any, context: any]>;
-    "uws:subscription": WSHook<[
-        ws: any,
-        topic: any,
-        newCount: number,
-        oldCount: number
-    ]>;
-}
-
-type WebSocketAdapter<RT = any, OT = any> = (hooks: Partial<WebSocketHooks & AdapterHooks>, opts: OT) => RT;
-declare function defineWebSocketAdapter<RT, OT>(factory: WebSocketAdapter<RT, OT>): WebSocketAdapter<RT, OT>;
-
-interface CrossWS extends WebSocketHooks {
-    upgrade: (req: WSRequest) => Promise<{
-        headers: HeadersInit;
-    }>;
-}
-interface CrossWSOptions {
-    resolve?: (info: WSRequest | WSPeer) => UserHooks | Promise<UserHooks>;
-}
-declare function createCrossWS(hooks: UserHooks, options: CrossWSOptions): CrossWS;
-
-export { type AdapterHooks, type CrossWS, type CrossWSOptions, type UserHooks, WSMessage, WSPeer, type WSRequest, type WebSocketAdapter, WebSocketError, type WebSocketHooks, type _UserHooks, createCrossWS, defineWebSocketAdapter, defineWebSocketHooks };
+export { AdapterOptions, CrossWS, createCrossWS };

package/dist/index.mjs

@@ -1,8 +1,10 @@
-export { W as WSMessage, a as WSPeer, c as createCrossWS, d as defineWebSocketAdapter } from './shared/crossws.a6b0a7cc.mjs';
-export { W as WebSocketError } from './shared/crossws.6f7f02b3.mjs';
+export { M as Message, P as Peer, c as createCrossWS, a as defineHooks, d as defineWebSocketAdapter } from './shared/crossws.61d46dae.mjs';
 
-function defineWebSocketHooks(hooks) {
-  return hooks;
+class WSError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = "WSError";
+  }
 }
 
-export { defineWebSocketHooks };
+export { WSError };

package/dist/shared/{crossws.a6b0a7cc.mjs → crossws.61d46dae.mjs}

@@ -1,50 +1,32 @@
-function defineWebSocketAdapter(factory) {
-  return factory;
-}
-
-function createCrossWS(hooks, options) {
-  const _callHook = options.resolve ? async function(name, info, ...args) {
-    const hooks2 = await options.resolve?.(info);
-    const hook = hooks2?.[name];
-    return hook?.(info, ...args);
-  } : void 0;
+function createCrossWS(opts = {}) {
+  const resolveHook = async (req, name) => {
+    const hooks = await opts.resolve?.(req);
+    return hooks?.[name];
+  };
   return {
-    async $(name, ...args) {
-      await Promise.all([hooks.$?.(name, ...args), _callHook?.(name, ...args)]);
+    // WS Hooks
+    async callHook(name, ...args) {
+      await opts.hooks?.[name]?.apply(void 0, args);
+      const hook = await resolveHook(args[0], name);
+      await hook?.apply(void 0, args);
     },
+    // Upgrade
     async upgrade(req) {
-      const upgradeResults = await Promise.all([
-        hooks.upgrade?.(req),
-        _callHook?.("upgrade", req)
+      const [res1, res2] = await Promise.all([
+        opts.hooks?.upgrade?.(req),
+        await resolveHook(req, "upgrade").then((h) => h?.(req))
       ]);
-      const headers = /* @__PURE__ */ Object.create(null);
-      for (const result of upgradeResults) {
-        if (result?.headers) {
-          Object.assign(headers, result.headers);
+      const headers = new Headers(res1?.headers);
+      if (res2?.headers) {
+        for (const [key, value] of new Headers(res2?.headers)) {
+          headers.append(key, value);
         }
       }
       return { headers };
     },
-    async message(peer, message) {
-      await Promise.all([
-        hooks.message?.(peer, message),
-        _callHook?.("message", peer, message)
-      ]);
-    },
-    async open(peer) {
-      await Promise.all([hooks.open?.(peer), _callHook?.("open", peer)]);
-    },
-    async close(peer, { code, reason }) {
-      await Promise.all([
-        hooks.close?.(peer, { code, reason }),
-        _callHook?.("close", peer, { code, reason })
-      ]);
-    },
-    async error(peer, error) {
-      await Promise.all([
-        hooks.error?.(peer, error),
-        _callHook?.("error", peer, error)
-      ]);
+    // Adapter hook
+    $callHook(name, ...args) {
+      return opts.adapterHooks?.[name].apply(void 0, args);
     }
   };
 }
@@ -78,7 +60,7 @@ function isPlainObject(value) {
   return true;
 }
 
-class WSMessage {
+class Message {
   constructor(rawData, isBinary) {
     this.rawData = rawData;
     this.isBinary = isBinary;
@@ -114,7 +96,7 @@ const ReadyStateMap = {
   2: "closing",
   3: "closed"
 };
-class WSPeer {
+class Peer {
   constructor(ctx) {
     this.ctx = ctx;
     __publicField(this, "_subscriptions", /* @__PURE__ */ new Set());
@@ -147,4 +129,11 @@ class WSPeer {
   }
 }
 
-export { WSMessage as W, WSPeer as a, createCrossWS as c, defineWebSocketAdapter as d, toBufferLike as t };
+function defineWebSocketAdapter(factory) {
+  return factory;
+}
+function defineHooks(hooks) {
+  return hooks;
+}
+
+export { Message as M, Peer as P, defineHooks as a, createCrossWS as c, defineWebSocketAdapter as d, toBufferLike as t };

package/dist/shared/crossws.a2e5c71e.d.cts

@@ -0,0 +1,112 @@
+declare class WSError extends Error {
+    constructor(...args: any[]);
+}
+
+declare class Message {
+    readonly rawData: any;
+    readonly isBinary?: boolean | undefined;
+    constructor(rawData: any, isBinary?: boolean | undefined);
+    text(): string;
+    toString(): string;
+}
+
+type ReadyState = 0 | 1 | 2 | 3;
+declare abstract class Peer<AdapterContext = any> implements WSRequest {
+    ctx: AdapterContext;
+    _subscriptions: Set<string>;
+    constructor(ctx: AdapterContext);
+    get id(): string | undefined;
+    get url(): string;
+    get headers(): HeadersInit;
+    get readyState(): ReadyState | -1;
+    abstract send(message: any, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, message: any, options?: {
+        compress?: boolean;
+    }): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    toString(): string;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+type Caller<T extends Record<string, (...args: any[]) => Promise<any>>, RT = null> = <K extends keyof T>(key: K, ...args: Parameters<T[K]>) => RT extends null ? Promise<ReturnType<T[K]>> : RT;
+interface AdapterOptions {
+    resolve?: ResolveHooks;
+    hooks?: Hooks;
+    adapterHooks?: AdapterHooks;
+}
+type Adapter<AdapterT, Options extends AdapterOptions> = (options?: Options) => AdapterT;
+declare function defineWebSocketAdapter<AdapterT, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
+interface CrossWS {
+    $callHook: Caller<AdapterHooks>;
+    callHook: Caller<Exclude<Hooks, "upgrade">, void>;
+    upgrade: (req: WSRequest) => Promise<{
+        headers?: HeadersInit;
+    }>;
+}
+interface WSRequest {
+    readonly url: string;
+    readonly headers: HeadersInit;
+}
+declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
+type ResolveHooks = (info: WSRequest | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type HookFn<ArgsT extends any[] = any, RT = void> = (info: Peer, ...args: ArgsT) => MaybePromise<RT>;
+interface Hooks extends Record<string, HookFn<any[], any>> {
+    /** Upgrading */
+    upgrade: (req: WSRequest) => MaybePromise<void | {
+        headers?: HeadersInit;
+    }>;
+    /** A message is received */
+    message: (peer: Peer, message: Message) => MaybePromise<void>;
+    /** A socket is opened */
+    open: (peer: Peer) => MaybePromise<void>;
+    /** A socket is closed */
+    close: (peer: Peer, details: {
+        code?: number;
+        reason?: string;
+    }) => MaybePromise<void>;
+    /** An error occurs */
+    error: (peer: Peer, error: WSError) => MaybePromise<void>;
+}
+interface AdapterHooks extends Record<string, HookFn<any[], any>> {
+    "bun:message": HookFn<[ws: any, message: any]>;
+    "bun:open": HookFn<[ws: any]>;
+    "bun:close": HookFn<[ws: any]>;
+    "bun:drain": HookFn<[]>;
+    "bun:error": HookFn<[ws: any, error: any]>;
+    "bun:ping": HookFn<[ws: any, data: any]>;
+    "bun:pong": HookFn<[ws: any, data: any]>;
+    "cloudflare:accept": HookFn<[]>;
+    "cloudflare:message": HookFn<[event: any]>;
+    "cloudflare:error": HookFn<[event: any]>;
+    "cloudflare:close": HookFn<[event: any]>;
+    "deno:open": HookFn<[]>;
+    "deno:message": HookFn<[event: any]>;
+    "deno:close": HookFn<[]>;
+    "deno:error": HookFn<[error: any]>;
+    "node:open": HookFn<[]>;
+    "node:message": HookFn<[data: any, isBinary: boolean]>;
+    "node:close": HookFn<[code: number, reason: Buffer]>;
+    "node:error": HookFn<[error: any]>;
+    "node:ping": HookFn<[data: Buffer]>;
+    "node:pong": HookFn<[data: Buffer]>;
+    "node:unexpected-response": HookFn<[req: any, res: any]>;
+    "node:upgrade": HookFn<[req: any]>;
+    "uws:open": HookFn<[ws: any]>;
+    "uws:message": HookFn<[ws: any, message: any, isBinary: boolean]>;
+    "uws:close": HookFn<[ws: any, code: number, message: any]>;
+    "uws:ping": HookFn<[ws: any, message: any]>;
+    "uws:pong": HookFn<[ws: any, message: any]>;
+    "uws:drain": HookFn<[ws: any]>;
+    "uws:upgrade": HookFn<[res: any, req: any, context: any]>;
+    "uws:subscription": HookFn<[
+        ws: any,
+        topic: any,
+        newCount: number,
+        oldCount: number
+    ]>;
+}
+
+export { type AdapterOptions as A, type CrossWS as C, type Hooks as H, Message as M, Peer as P, type ResolveHooks as R, WSError as W, type Caller as a, type Adapter as b, type WSRequest as c, defineWebSocketAdapter as d, defineHooks as e, type AdapterHooks as f };