alepha 0.13.0 → 0.13.2

package/dist/websocket/index.d.cts

@@ -1,861 +0,0 @@
-import * as alepha42 from "alepha";
-import { Alepha, Descriptor, KIND, Static, TObject, TString, TUnion } from "alepha";
-import * as alepha_logger1 from "alepha/logger";
-import * as alepha_topic0 from "alepha/topic";
-import { IncomingMessage } from "node:http";
-import { WebSocket as WebSocket$1, WebSocketServer } from "ws";
-
-//#region src/websocket/descriptors/$channel.d.ts
-type TWSObject = TObject | TUnion;
-/**
- * Channel descriptor options
- */
-interface ChannelDescriptorOptions<TClient extends TWSObject, TServer extends TWSObject> {
-  /**
-   * WebSocket endpoint path (e.g., "/ws/chat")
-   */
-  path: string;
-  /**
-   * Optional description for documentation
-   */
-  description?: string;
-  /**
-   * Message schemas for bidirectional communication
-   */
-  schema: {
-    /**
-     * Optional room ID schema validation
-     * Default: t.text() (any string)
-     * Can be enforced at application level: t.uuid(), t.regex(/^[a-f0-9\-]{36}$/)
-     */
-    roomId?: TString;
-    /**
-     * Messages from server to client
-     * This is what clients will receive
-     */
-    in: TClient;
-    /**
-     * Messages from client to server
-     * This is what the server will receive
-     */
-    out: TServer;
-  };
-}
-/**
- * Defines a WebSocket channel with specified client and server message schemas.
- *
- * Channels must be defined as class properties to be registered in the Alepha context.
- * They define the "vocabulary" for communication - the schema for messages flowing
- * in both directions (server→client and client→server).
- *
- * @example Server-side with $websocket
- * ```typescript
- * class ChatController {
- *   // Channel must be defined inside a class
- *   chatChannel = $channel({
- *     path: "/ws/chat",
- *     description: "Real-time chat channel",
- *     schema: {
- *       // Server → Client messages
- *       in: t.union([
- *         t.object({
- *           type: t.const("append"),
- *           content: t.text(),
- *           username: t.text()
- *         }),
- *         t.object({
- *           type: t.const("system"),
- *           message: t.text()
- *         })
- *       ]),
- *       // Client → Server messages
- *       out: t.object({
- *         content: t.text()
- *       })
- *     }
- *   });
- *
- *   chat = $websocket({
- *     channel: this.chatChannel,
- *     handler: async ({ message, reply }) => {
- *       await reply({
- *         message: { type: "append", content: message.content, username: "user" }
- *       });
- *     }
- *   });
- * }
- * ```
- *
- * @example Browser-side with useRoom
- * ```typescript
- * // Define channel in a class for browser context
- * class ChatClient {
- *   chatChannel = $channel({
- *     path: "/ws/chat",
- *     schema: { in: inSchema, out: outSchema }
- *   });
- * }
- *
- * // Use in React component
- * function Chat() {
- *   const client = useInject(ChatClient);
- *   const chat = useRoom({ roomId: "lobby", channel: client.chatChannel, handler: ... }, []);
- * }
- * ```
- */
-declare const $channel: {
-  <TClient extends TWSObject, TServer extends TWSObject>(options: ChannelDescriptorOptions<TClient, TServer>): ChannelDescriptor<TClient, TServer>;
-  [KIND]: typeof ChannelDescriptor;
-};
-declare class ChannelDescriptor<TClient extends TWSObject, TServer extends TWSObject> extends Descriptor<ChannelDescriptorOptions<TClient, TServer>> {}
-//#endregion
-//#region src/websocket/interfaces/WebSocketInterfaces.d.ts
-/**
- * WebSocket connection interface
- */
-interface WebSocketConnection {
-  /**
-   * Unique connection ID
-   */
-  id: string;
-  /**
-   * User ID (if authenticated and security module is used)
-   */
-  userId?: string;
-  /**
-   * Room IDs that this connection is currently in
-   */
-  roomIds: string[];
-  /**
-   * Send a message to this connection
-   */
-  send(message: any): Promise<void>;
-  /**
-   * Close this connection
-   */
-  close(code?: number, reason?: string): Promise<void>;
-  /**
-   * Connection metadata (custom data)
-   */
-  metadata?: Record<string, any>;
-  /**
-   * Connection state
-   */
-  readyState: WebSocketState;
-}
-/**
- * WebSocket state enum
- */
-declare enum WebSocketState {
-  CONNECTING = 0,
-  OPEN = 1,
-  CLOSING = 2,
-  CLOSED = 3,
-}
-/**
- * WebSocket endpoint configuration (server-side)
- */
-interface WebSocketDescriptorOptions<TClient extends TWSObject, TServer extends TWSObject> {
-  /**
-   * Channel definition with schema and path
-   */
-  channel: ChannelDescriptor<TClient, TServer>;
-  /**
-   * Handler for incoming messages from clients
-   */
-  handler: WebSocketHandler<TClient, TServer>;
-  /**
-   * Optional connection handler (called when a client connects)
-   */
-  onConnect?: (params: {
-    /**
-     * Unique connection ID of the client
-     */
-    connectionId: string;
-    /**
-     * User ID of the connected client (if authenticated and security module is used)
-     */
-    userId?: string;
-    /**
-     * Room IDs that the client is connecting to
-     */
-    roomIds: string[];
-  }) => Promise<void> | void;
-  /**
-   * Optional disconnection handler (called when a client disconnects)
-   */
-  onDisconnect?: (params: {
-    /**
-     * Unique connection ID of the client
-     */
-    connectionId: string;
-    /**
-     * User ID of the connected client (if authenticated and security module is used)
-     */
-    userId?: string;
-    /**
-     * Room IDs that the client was connected to
-     */
-    roomIds: string[];
-  }) => Promise<void> | void;
-  /**
-   * Change WebSocket server provider (for custom implementations)
-   */
-  provider?: any;
-  /**
-   * Whether to enforce security (authentication, authorization) on this WebSocket endpoint
-   * Requires alepha/security integration
-   */
-  secure?: boolean;
-  /**
-   * Limit number of connections per user (if authenticated)
-   */
-  maxConnectionsPerUser?: number;
-}
-/**
- * WebSocket message handler
- */
-type WebSocketHandler<TClient extends TWSObject, TServer extends TWSObject> = (context: WebSocketHandlerContext<TClient, TServer>) => Promise<void> | void;
-/**
- * WebSocket handler context
- */
-interface WebSocketHandlerContext<TClient extends TWSObject, TServer extends TWSObject> {
-  /**
-   * Unique connection ID of the client
-   */
-  connectionId: string;
-  /**
-   * User ID of the connected client (if authenticated and security module is used)
-   */
-  userId?: string;
-  /**
-   * Room ID that the client sent the message from
-   */
-  roomId: string;
-  /**
-   * The parsed and validated message from the client
-   */
-  message: Static<TServer>;
-  /**
-   * Reply function tailored to current context (connectionId, roomId)
-   */
-  reply: (options: {
-    /**
-     * Message to send
-     */
-    message: Static<TClient>;
-    /**
-     * Optional: specify room ID to send to (defaults to sender's room ID)
-     */
-    roomId?: string;
-    /**
-     * Optional: exclude the sender connection from receiving the message
-     * Will populate exceptConnectionIds with sender connection ID behind the scenes
-     */
-    exceptSelf?: boolean;
-    /**
-     * Optional: exclude specific connection IDs from receiving the message
-     */
-    exceptConnectionIds?: string[];
-    /**
-     * Optional: exclude specific user IDs from receiving the message
-     * Requires alepha/security integration
-     */
-    exceptUserIds?: string[];
-  }) => Promise<void>;
-}
-/**
- * Emit options for sending messages from the server
- */
-interface EmitOptions<TClient extends TWSObject> {
-  /**
-   * Message to send to clients
-   */
-  message: Static<TClient>;
-  /**
-   * Room ID to send the message to
-   */
-  roomId?: string;
-  /**
-   * Room IDs to send the message to
-   */
-  roomIds?: string[];
-  /**
-   * User ID to send the message to (if authenticated)
-   */
-  userId?: string;
-  /**
-   * User IDs to send the message to (if authenticated)
-   */
-  userIds?: string[];
-  /**
-   * Connection ID to send the message to
-   */
-  connectionId?: string;
-  /**
-   * Connection IDs to send the message to
-   */
-  connectionIds?: string[];
-  /**
-   * Optional: exclude specific connection IDs from receiving the message
-   */
-  exceptConnectionIds?: string[];
-  /**
-   * Optional: exclude specific user IDs from receiving the message
-   * Requires alepha/security integration
-   */
-  exceptUserIds?: string[];
-}
-//#endregion
-//#region src/websocket/providers/WebSocketServerProvider.d.ts
-/**
- * Abstract WebSocket server provider
- *
- * This class provides the base interface that must be implemented by
- * platform-specific providers (Node.js, Browser, etc.)
- */
-declare abstract class WebSocketServerProvider {
-  /**
-   * Register a WebSocket endpoint with its channel configuration
-   */
-  abstract registerEndpoint<TClient extends TWSObject, TServer extends TWSObject>(config: WebSocketDescriptorOptions<TClient, TServer>): void;
-  /**
-   * Emit a message to clients based on targeting criteria
-   *
-   * This method distributes messages across all server instances via pub/sub.
-   */
-  abstract emit<TClient extends TWSObject>(channelPath: string, options: EmitOptions<TClient>): Promise<void>;
-  /**
-   * Get all active connections (local to this server instance)
-   */
-  abstract getConnections(): WebSocketConnection[];
-  /**
-   * Get connections in a specific room (local to this server instance)
-   */
-  abstract getRoomConnections(roomId: string): WebSocketConnection[];
-  /**
-   * Get connections for a specific user (local to this server instance)
-   */
-  abstract getUserConnections(userId: string): WebSocketConnection[];
-  /**
-   * Close a specific connection
-   */
-  abstract closeConnection(connectionId: string, code?: number, reason?: string): Promise<void>;
-}
-//#endregion
-//#region src/websocket/descriptors/$websocket.d.ts
-/**
- * Defines a WebSocket server endpoint for a specific channel.
- *
- * Server-side only. Creates a WebSocket endpoint that:
- * - Accepts connections from clients
- * - Validates incoming messages against the channel schema
- * - Provides room-based messaging
- * - Integrates with alepha/security for authentication (optional)
- * - Supports horizontal scaling via alepha/topic
- *
- * @example
- * ```typescript
- * class ChatController {
- *   chat = $websocket({
- *     channel: chatChannel,
- *     handler: async ({ connectionId, userId, roomId, message, reply }) => {
- *       // Broadcast to all in room except sender
- *       await reply({
- *         message: {
- *           type: "append",
- *           username: userId,
- *           content: message.content
- *         },
- *         exceptSelf: true
- *       });
- *     }
- *   });
- *
- *   async broadcastAnnouncement(roomId: string, text: string) {
- *     await this.chat.emit({
- *       roomId,
- *       message: {
- *         type: "append",
- *         username: "System",
- *         content: text
- *       }
- *     });
- *   }
- * }
- * ```
- */
-declare const $websocket: {
-  <TClient extends TWSObject, TServer extends TWSObject>(options: WebSocketDescriptorOptions<TClient, TServer>): WebSocketDescriptor<TClient, TServer>;
-  [KIND]: typeof WebSocketDescriptor;
-};
-declare class WebSocketDescriptor<TClient extends TWSObject, TServer extends TWSObject> extends Descriptor<WebSocketDescriptorOptions<TClient, TServer>> {
-  protected readonly webSocketServerProvider: WebSocketServerProvider;
-  protected onInit(): void;
-  /**
-   * Emit message to clients
-   *
-   * Send messages from the server to connected clients based on targeting criteria.
-   * Messages are distributed across all server instances via pub/sub.
-   *
-   * @example
-   * ```typescript
-   * // Send to specific room
-   * await websocket.emit({
-   *   roomId: "room-123",
-   *   message: { type: "update", data: {...} }
-   * });
-   *
-   * // Send to specific user (all their connections)
-   * await websocket.emit({
-   *   userId: "user-456",
-   *   message: { type: "notification", text: "Hello!" }
-   * });
-   *
-   * // Send to multiple rooms, except certain users
-   * await websocket.emit({
-   *   roomIds: ["room-1", "room-2"],
-   *   exceptUserIds: ["user-123"],
-   *   message: { type: "broadcast", content: "System announcement" }
-   * });
-   * ```
-   */
-  emit(options: EmitOptions<TClient>): Promise<void>;
-}
-//#endregion
-//#region src/websocket/errors/WebSocketError.d.ts
-/**
- * Base WebSocket error class
- */
-declare class WebSocketError extends Error {
-  readonly code?: number | undefined;
-  constructor(message: string, code?: number | undefined);
-}
-/**
- * Error thrown when WebSocket connection fails
- */
-declare class WebSocketConnectionError extends WebSocketError {
-  constructor(message: string, code?: number);
-}
-/**
- * Error thrown when WebSocket message validation fails
- */
-declare class WebSocketValidationError extends WebSocketError {
-  constructor(message: string);
-}
-//#endregion
-//#region src/websocket/services/RoomManager.d.ts
-/**
- * Manages WebSocket room memberships
- *
- * Rooms are logical groupings of connections. A connection can be in multiple rooms,
- * and messages can be targeted to specific rooms.
- */
-declare class RoomManager {
-  protected readonly log: alepha_logger1.Logger;
-  /**
-   * Maps roomId → Set<connectionId>
-   */
-  protected readonly rooms: Map<string, Set<string>>;
-  /**
-   * Maps connectionId → Set<roomId>
-   * Inverse index for fast lookup of connection's rooms
-   */
-  protected readonly connectionRooms: Map<string, Set<string>>;
-  /**
-   * Join a connection to one or more rooms
-   */
-  joinRooms(connectionId: string, roomIds: string[]): void;
-  /**
-   * Join a connection to a room
-   */
-  joinRoom(connectionId: string, roomId: string): void;
-  /**
-   * Leave a connection from a room
-   */
-  leaveRoom(connectionId: string, roomId: string): void;
-  /**
-   * Remove a connection from all rooms
-   */
-  leaveAllRooms(connectionId: string): void;
-  /**
-   * Get all connection IDs in a room
-   */
-  getRoomConnections(roomId: string): string[];
-  /**
-   * Get all room IDs for a connection
-   */
-  getConnectionRooms(connectionId: string): string[];
-  /**
-   * Check if a connection is in a room
-   */
-  isInRoom(connectionId: string, roomId: string): boolean;
-  /**
-   * Get all active rooms
-   */
-  getAllRooms(): string[];
-  /**
-   * Get total number of connections across all rooms
-   */
-  getTotalConnections(): number;
-  /**
-   * Get room statistics
-   */
-  getStats(): {
-    totalRooms: number;
-    totalConnections: number;
-    roomSizes: Map<string, number>;
-  };
-}
-//#endregion
-//#region src/websocket/services/WebSocketClient.d.ts
-declare const envSchema$1: alepha42.TObject<{
-  WEBSOCKET_URL: alepha42.TString;
-  WEBSOCKET_RECONNECT_INTERVAL: alepha42.TInteger;
-  WEBSOCKET_MAX_RECONNECT_ATTEMPTS: alepha42.TInteger;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-/**
- * WebSocket channel connection
- *
- * Manages a single WebSocket connection to a channel with multiple room subscriptions.
- * One connection can handle multiple rooms on the same channel.
- */
-declare class WebSocketChannelConnection<TClient extends TWSObject, TServer extends TWSObject> {
-  protected readonly channel: ChannelDescriptor<TClient, TServer>;
-  protected readonly options: {
-    url?: string;
-    autoReconnect?: boolean;
-    reconnectInterval?: number;
-    maxReconnectAttempts?: number;
-  };
-  protected readonly env: Static<typeof envSchema$1>;
-  protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger1.Logger;
-  protected ws?: WebSocket;
-  protected reconnectAttempts: number;
-  protected reconnectTimer?: number;
-  protected messageQueue: Array<{
-    roomId: string;
-    message: Static<TServer>;
-  }>;
-  protected subscriptions: Map<string, (message: Static<TClient>) => void>;
-  isConnected: boolean;
-  isConnecting: boolean;
-  isError: boolean;
-  error?: Error;
-  protected onConnectCallbacks: Set<() => void>;
-  protected onDisconnectCallbacks: Set<() => void>;
-  protected onErrorCallbacks: Set<(error: Error) => void>;
-  constructor(channel: ChannelDescriptor<TClient, TServer>, options: {
-    url?: string;
-    autoReconnect?: boolean;
-    reconnectInterval?: number;
-    maxReconnectAttempts?: number;
-  }, env: Static<typeof envSchema$1>);
-  /**
-   * Build WebSocket URL
-   */
-  protected buildUrl(): string;
-  /**
-   * Subscribe to a room on this channel
-   */
-  subscribe(roomId: string, handler: (message: Static<TClient>) => void, callbacks?: {
-    onConnect?: () => void;
-    onDisconnect?: () => void;
-    onError?: (error: Error) => void;
-  }): () => void;
-  /**
-   * Connect to WebSocket server
-   */
-  protected connect(): Promise<void>;
-  /**
-   * Handle incoming message
-   */
-  protected handleMessage(data: string): void;
-  /**
-   * Send message to a specific room
-   */
-  send(roomId: string, message: Static<TServer>): Promise<void>;
-  /**
-   * Schedule reconnection
-   */
-  protected scheduleReconnect(): void;
-  /**
-   * Disconnect from server
-   */
-  disconnect(): void;
-  /**
-   * Reconnect manually
-   */
-  reconnect(): void;
-  /**
-   * Check if subscribed to a room
-   */
-  hasRoom(roomId: string): boolean;
-  /**
-   * Get all subscribed rooms
-   */
-  getRooms(): string[];
-}
-/**
- * WebSocket Client Service
- *
- * Manages WebSocket connections from the client side (browser).
- * One connection per channel, multiple rooms per connection.
- */
-declare class WebSocketClient {
-  protected readonly log: alepha_logger1.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly env: {
-    WEBSOCKET_URL: string;
-    WEBSOCKET_RECONNECT_INTERVAL: number;
-    WEBSOCKET_MAX_RECONNECT_ATTEMPTS: number;
-  };
-  protected connections: Map<string, WebSocketChannelConnection<any, any>>;
-  /**
-   * Subscribe to a room on a channel
-   */
-  subscribe<TClient extends TWSObject, TServer extends TWSObject>(roomId: string, channel: ChannelDescriptor<TClient, TServer>, handler: (message: Static<TClient>) => void, options?: {
-    url?: string;
-    autoReconnect?: boolean;
-    reconnectInterval?: number;
-    maxReconnectAttempts?: number;
-    onConnect?: () => void;
-    onDisconnect?: () => void;
-    onError?: (error: Error) => void;
-  }): () => void;
-  /**
-   * Send message to a room on a channel
-   */
-  send<TClient extends TWSObject, TServer extends TWSObject>(roomId: string, channel: ChannelDescriptor<TClient, TServer>, message: Static<TServer>): Promise<void>;
-  /**
-   * Get connection for a channel
-   */
-  getConnection<TClient extends TWSObject, TServer extends TWSObject>(channel: ChannelDescriptor<TClient, TServer>): WebSocketChannelConnection<TClient, TServer> | undefined;
-  /**
-   * Disconnect all connections
-   */
-  disconnectAll(): void;
-}
-//#endregion
-//#region src/websocket/services/WebSocketTopicService.d.ts
-/**
- * WebSocket message distribution event
- */
-declare const webSocketMessageSchema: {
-  payload: alepha42.TObject<{
-    /**
-     * Channel path (e.g., "/ws/chat")
-     */
-    channelPath: alepha42.TString;
-    /**
-     * Target room ID(s)
-     */
-    roomIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-    /**
-     * Target user ID(s)
-     */
-    userIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-    /**
-     * Target connection ID(s)
-     */
-    connectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-    /**
-     * Exclude connection ID(s) from receiving the message
-     */
-    exceptConnectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-    /**
-     * Exclude user ID(s) from receiving the message
-     */
-    exceptUserIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-    /**
-     * The message payload to send
-     */
-    message: alepha42.TAny;
-  }>;
-};
-/**
- * WebSocket Topic Service
- *
- * Manages pub/sub messaging for WebSocket connections across multiple server instances.
- * Uses alepha/topic for cross-instance message distribution, enabling horizontal scaling.
- *
- * When a WebSocket message needs to be sent:
- * 1. Server instance A publishes to the topic
- * 2. All server instances (A, B, C, etc.) receive the message
- * 3. Each instance sends to its local connections that match the criteria
- *
- * This enables:
- * - Multiple server instances handling WebSocket connections
- * - Redis-backed message distribution (with alepha/topic/redis)
- * - Horizontal scaling without losing messages
- */
-declare class WebSocketTopicService {
-  protected readonly log: alepha_logger1.Logger;
-  /**
-   * Handler function to be called when a message is received from the topic
-   * This is set by the WebSocket provider during initialization
-   */
-  messageHandler?: (event: Static<(typeof webSocketMessageSchema)["payload"]>) => Promise<void>;
-  /**
-   * Topic for distributing WebSocket messages across server instances
-   */
-  readonly topic: alepha_topic0.TopicDescriptor<{
-    payload: alepha42.TObject<{
-      /**
-       * Channel path (e.g., "/ws/chat")
-       */
-      channelPath: alepha42.TString;
-      /**
-       * Target room ID(s)
-       */
-      roomIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-      /**
-       * Target user ID(s)
-       */
-      userIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-      /**
-       * Target connection ID(s)
-       */
-      connectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-      /**
-       * Exclude connection ID(s) from receiving the message
-       */
-      exceptConnectionIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-      /**
-       * Exclude user ID(s) from receiving the message
-       */
-      exceptUserIds: alepha42.TOptional<alepha42.TArray<alepha42.TString>>;
-      /**
-       * The message payload to send
-       */
-      message: alepha42.TAny;
-    }>;
-  }>;
-  /**
-   * Publish a message to be distributed across all server instances
-   */
-  publish(event: Static<(typeof webSocketMessageSchema)["payload"]>): Promise<void>;
-  /**
-   * Set the handler for incoming messages
-   */
-  setMessageHandler(handler: (event: Static<(typeof webSocketMessageSchema)["payload"]>) => Promise<void>): void;
-}
-//#endregion
-//#region src/websocket/providers/NodeWebSocketServerProvider.d.ts
-declare const envSchema: alepha42.TObject<{
-  WEBSOCKET_PATH: alepha42.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-declare class NodeWebSocketServerProvider extends WebSocketServerProvider {
-  protected readonly alepha: Alepha;
-  protected readonly roomManager: RoomManager;
-  protected readonly topicService: WebSocketTopicService;
-  protected readonly log: alepha_logger1.Logger;
-  protected readonly env: {
-    WEBSOCKET_PATH: string;
-  };
-  protected wss?: WebSocketServer;
-  protected endpoints: Map<string, WebSocketDescriptorOptions<any, any>>;
-  protected connections: Map<string, WebSocketConnection>;
-  protected userConnections: Map<string, Set<string>>;
-  protected nextConnectionId: number;
-  registerEndpoint<TClient extends TWSObject, TServer extends TWSObject>(config: WebSocketDescriptorOptions<TClient, TServer>): void;
-  emit<TClient extends TWSObject>(channelPath: string, options: EmitOptions<TClient>): Promise<void>;
-  getConnections(): WebSocketConnection[];
-  getRoomConnections(roomId: string): WebSocketConnection[];
-  getUserConnections(userId: string): WebSocketConnection[];
-  closeConnection(connectionId: string, code?: number, reason?: string): Promise<void>;
-  protected handleUpgrade(request: IncomingMessage, socket: any, head: Buffer): boolean;
-  protected handleConnection<TClient extends TWSObject, TServer extends TWSObject>(ws: WebSocket$1, endpoint: WebSocketDescriptorOptions<TClient, TServer>, request: IncomingMessage): void;
-  protected extractRoomIds(url: URL): string[];
-  /**
-   * Send message to local connections based on targeting criteria
-   * This is called by the topic service when a message is received
-   */
-  protected sendToLocalConnections(channelPath: string, message: any, criteria: {
-    roomIds?: string[];
-    userIds?: string[];
-    connectionIds?: string[];
-    exceptConnectionIds?: string[];
-    exceptUserIds?: string[];
-  }): Promise<void>;
-  protected readonly start: alepha42.HookDescriptor<"start">;
-  protected readonly ready: alepha42.HookDescriptor<"ready">;
-  protected readonly stop: alepha42.HookDescriptor<"stop">;
-}
-declare class NodeWebSocketConnection implements WebSocketConnection {
-  readonly id: string;
-  readonly userId: string | undefined;
-  readonly roomIds: string[];
-  protected readonly ws: WebSocket$1;
-  protected readonly provider: NodeWebSocketServerProvider;
-  protected readonly endpoint: WebSocketDescriptorOptions<any, any>;
-  protected readonly log: alepha_logger1.Logger;
-  metadata?: Record<string, any>;
-  constructor(id: string, userId: string | undefined, roomIds: string[], ws: WebSocket$1, provider: NodeWebSocketServerProvider, endpoint: WebSocketDescriptorOptions<any, any>);
-  get readyState(): WebSocketState;
-  send(message: any): Promise<void>;
-  close(code?: number, reason?: string): Promise<void>;
-  handleMessage(data: any): Promise<void>;
-}
-//#endregion
-//#region src/websocket/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    /**
-     * Fires when a WebSocket connection is established
-     */
-    "websocket:connect": {
-      connectionId: string;
-      path: string;
-    };
-    /**
-     * Fires when a WebSocket connection is closed
-     */
-    "websocket:disconnect": {
-      connectionId: string;
-      path: string;
-      code?: number;
-      reason?: string;
-    };
-    /**
-     * Fires when a WebSocket message is received
-     */
-    "websocket:message": {
-      connectionId: string;
-      path: string;
-      message: any;
-    };
-    /**
-     * Fires when a WebSocket error occurs
-     */
-    "websocket:error": {
-      connectionId: string;
-      path: string;
-      error: Error;
-    };
-  }
-}
-/**
- * Provides real-time bidirectional communication using WebSockets.
- *
- * The WebSockets module enables building real-time applications using the `$websocket` descriptor
- * on class properties. It provides automatic connection management, message routing, type-safe
- * message handling, and seamless integration with other Alepha modules.
- *
- * On the server side (Node.js), it uses the 'ws' library to create a WebSocket server.
- * On the client side (browser), it uses the native WebSocket API.
- *
- * @see {@link $websocket}
- * @module alepha.websockets
- */
-declare const AlephaWebSocket: alepha42.Service<alepha42.Module>;
-//#endregion
-export { $channel, $websocket, AlephaWebSocket, ChannelDescriptor, ChannelDescriptorOptions, EmitOptions, NodeWebSocketConnection, NodeWebSocketServerProvider, RoomManager, TWSObject, WebSocketChannelConnection, WebSocketClient, WebSocketConnection, WebSocketConnectionError, WebSocketDescriptor, WebSocketDescriptorOptions, WebSocketError, WebSocketHandler, WebSocketHandlerContext, WebSocketServerProvider, WebSocketState, WebSocketTopicService, WebSocketValidationError };
-//# sourceMappingURL=index.d.cts.map