@eleven-am/pondsocket 0.1.141 → 0.1.143

package/types.d.ts

@@ -1,16 +1,17 @@
 import { Server as HTTPServer } from 'http';
 
 import {
-    PondMessage,
-    PondPresence,
+    IncomingConnection,
+    JoinParams,
     PondAssigns,
     PondEvent,
-    PondPath,
-    JoinParams,
     PondEventMap,
-    IncomingConnection, UserData,
+    PondMessage,
+    PondPath,
+    PondPresence,
+    UserData,
 } from '@eleven-am/pondsocket-common';
-import { WebSocketServer } from 'ws';
+import { WebSocket, WebSocketServer } from 'ws';
 
 export * from '@eleven-am/pondsocket-common';
 
@@ -21,143 +22,126 @@ export interface LeaveEvent<EventTypes extends PondEventMap = PondEventMap, Pres
 
 export type LeaveCallback<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: LeaveEvent<EventTypes, PresenceType, AssignType>) => void;
 
-export declare class AbstractRequest<Path extends string, PresenceType extends PondPresence, AssignType extends PondAssigns> {
-    event: PondEvent<Path>;
-
-    channelName: string;
-
-    assigns: Record<string, AssignType>;
-
-    presence: Record<string, PresenceType>;
-}
-
-export declare class EventRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
-    user: UserData<PresenceType, AssignType>;
-
-    channel: Channel;
-}
-
-export declare class EventResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
-    /**
-     * @desc Whether the server has responded to the request
-     */
-    hasResponded: boolean;
-
-    /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
-     */
-    accept (assigns?: AssignType): EventResponse;
-
-    /**
-     * @desc Rejects the request and optionally assigns data to the client
-     * @param message - the error message
-     * @param errorCode - the error code
-     * @param assigns - the data to assign to the client
-     */
-    reject (message?: string, errorCode?: number, assigns?: AssignType): EventResponse;
+export type RequestHandler<Request, Response> = (request: Request, response: Response) => void | Promise<void>;
 
-    /**
-     * @desc Emits a direct message to the client, accepting the request
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
-     */
-    send (event: string, payload: PondMessage, assigns?: AssignType): void;
+export declare class PondSocket {
+    constructor(server?: HTTPServer, socketServer?: WebSocketServer);
 
     /**
-     * @desc Emits a direct message to the client without accepting the request
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @desc Specifies the port to listen on
+     * @param args - the arguments to pass to the server
      */
-    sendOnly <Key extends keyof EventType> (event: Key, payload: EventType[Key], assigns?: AssignType): void;
+    listen(...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
-     * @desc Sends a message to all clients in the channel
-     * @param event - the event to send
-     * @param payload - the payload to send
+     * @desc Closes the server
+     * @param callback - the callback to call when the server is closed
      */
-    broadcast <Key extends keyof EventType> (event: Key, payload: EventType[Key]): EventResponse;
+    close(callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
-     * @desc Sends a message to all clients in the channel except the client making the request
-     * @param event - the event to send
-     * @param payload - the payload to send
+     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
+     * @param path - the pattern to accept || can also be a regex
+     * @param handler - the handler function to authenticate the socket
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const token = req.query.token;
+     *    if (!token)
+     *       return res.reject('No token provided');
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
      */
-    broadcastFromUser <Key extends keyof EventType> (event: Key, payload: EventType[Key]): EventResponse;
+    createEndpoint<Path extends string>(path: PondPath<Path>, handler: RequestHandler<IncomingConnection<Path>, ConnectionResponse>): Endpoint;
+}
 
+export declare class Endpoint {
     /**
-     * @desc Sends a message to a set of clients in the channel
-     * @param event - the event to send
-     * @param payload - the payload to send
-     * @param userIds - the ids of the clients to send the message to
+     * @desc Adds a new PondChannel to this path on this endpoint
+     * @param {PondPath<string>} path - The path to add the channel to
+     * @param {RequestHandler} handler - The handler to use to authenticate the client
+     * @returns {PondChannel} - The PondChannel instance for the new channel
+     *
+     * @example
+     * const channel = endpoint.createChannel('/chat', (request, response) => {
+     *     if (request.user.assigns.admin)
+     *         response.accept();
+     *
+     *     else
+     *         response.reject('You are not an admin', 403);
+     * });
      */
-    sendToUsers <Key extends keyof EventType> (event: Key, payload: EventType[Key], userIds: string[]): EventResponse;
+    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns>(path: PondPath<Path>, handler: RequestHandler<JoinRequest<Path, PresenceType, AssignType>, JoinResponse<EventType, PresenceType, AssignType>>): PondChannel<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Tracks a user's presence in the channel
-     * @param presence - the initial presence data
-     * @param userId - the id of the user to track
+     * @desc Broadcasts a message to all clients connected to this endpoint
+     * @param {string} event - The event to broadcast.
+     * @param {PondMessage} payload - The payload to broadcast.
+     * @returns {void}
      */
-    trackPresence (presence: PresenceType, userId?: string): EventResponse;
+    broadcast(event: string, payload: PondMessage): void;
 
     /**
-     * @desc Updates a user's presence in the channel
-     * @param presence - the updated presence data
-     * @param userId - the id of the user to update
+     * @desc Closes specific clients connected to this endpoint
+     * @param {string | string[]} clientIds - The ids of the clients to close.
      */
-    updatePresence (presence: PresenceType, userId?: string): EventResponse;
+    closeConnection(clientIds: string | string[]): void;
 
     /**
-     * @desc Removes a user's presence from the channel
-     * @param userId - the id of the user to remove
+     * @desc Returns all the clients connected to this endpoint
      */
-    unTrackPresence (userId?: string): EventResponse;
+    getClients(): WebSocket[];
+}
 
+export declare class PondChannel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
-     * @desc Evicts a user from the channel
-     * @param reason - the reason for the eviction
-     * @param userId - the id of the user to evict,
+     * @desc Handles an event request made by a user
+     * @param {PondPath<string>} event - The event to handle
+     * @param {RequestHandler} handler - The handlers to execute when the event is received
+     * @example
+     * pond.onEvent('echo', (request, response) => {
+     *     response.reply('echo', {
+     *         message: request.event.payload,
+     *     });
+     * });
      */
-    evictUser (reason: string, userId?: string): void;
+    onEvent<Event extends string>(event: PondPath<Event>, handler: RequestHandler<EventRequest<Event, PresenceType, AssignType>, EventResponse<EventType, PresenceType, AssignType>>): void;
 
     /**
-     * @desc Closes the channel from the server side for all clients
-     * @param reason - the reason for closing the channel
+     * @desc Broadcasts a message to all users in a channel
+     * @param event - The event to broadcast
+     * @param payload - The payload to send
+     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
+     * @example
+     * pond.broadcast('echo', {
+     *    message: 'Hello World',
+     *    timestamp: Date.now(),
+     *    channel: 'my_channel',
+     *});
      */
-    closeChannel (reason: string): void;
-}
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key], channelName?: string): void;
 
-export declare class Endpoint {
     /**
-     * @desc Adds a new PondChannel to this path on this endpoint
-     * @param path - The path to add the channel to
-     * @param handler - The handler to use to authenticate the client
-     *
+     * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
+     * @param {LeaveCallback} callback - The callback to execute when a user leaves
      * @example
-     * const channel = endpoint.createChannel('/chat', (request, response) => {
-     *     if (request.user.assigns.admin)
-     *         response.accept();
-     *
-     *     else
-     *         response.reject('You are not an admin', 403);
+     * pond.onLeave((event) => {
+     *     // Clean up resources
      * });
      */
-    createChannel<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> (path: PondPath<Path>, handler: (request: JoinRequest<Path, PresenceType, AssignType>, response: JoinResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): PondChannel<EventType, PresenceType, AssignType>;
-
-    /**
-     * @desc Broadcasts a message to all clients connected to this endpoint
-     * @param event - The event to broadcast
-     * @param payload - The payload to broadcast
-     */
-    broadcast (event: string, payload: PondMessage): void;
+    onLeave(callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
 
     /**
-     * @desc Closes specific clients connected to this endpoint
-     * @param clientIds - The id for the client / clients to close
+     * @desc Gets a channel by name
+     * @param {string} channelName - The name of the channel to get
+     * @returns {Channel} - The channel instance
+     * @example
+     * const channel = pond.getChannel('my_channel')!;
      */
-    closeConnection (clientIds: string | string[]): void;
+    getChannel(channelName: string): Channel<EventType, PresenceType, AssignType> | null;
 }
 
 export declare class Channel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
@@ -169,76 +153,92 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
     /**
      * @desc Gets the current assign data for the channel.
      */
-    getAssigns (): Record<string, AssignType>;
+    getAssigns(): Record<string, AssignType>;
 
     /**
      * @desc Gets the current presence data for the channel.
      */
-    getPresences (): Record<string, PresenceType>;
+    getPresences(): Record<string, PresenceType>;
 
     /**
      * @desc Gets the assign date for a specific user.
-     * @param userId - The id of the user to get the assign data for.
+     * @param {string} userId - The id of the user to get the data for.
      */
-    getUserData (userId: string): AssignType | null;
+    getUserData(userId: string): AssignType | null;
 
     /**
      * @desc Broadcasts a message to every client in the channel,
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The message to send.
      */
-    broadcastMessage <Key extends keyof EventType> (event: Key, payload: EventType[Key]): void;
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key]): void;
 
     /**
      * @desc Broadcasts a message to every client in the channel except the sender,
-     * @param userId - The id of the user to send the message from.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @param {string} userId - The id of the user to exclude from the broadcast.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The message to send.
      */
-    broadcastMessageFromUser <Key extends keyof EventType> (userId: string, event: Key, payload: EventType[Key]): void;
+    broadcastFrom<Key extends keyof EventType>(userId: string, event: Key, payload: EventType[Key]): void;
 
     /**
      * @desc Sends a message to a specific client in the channel.
-     * @param userId - The id of the user to send the message to.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @param {string | string[]} clientIds - The id of the client to send the message to.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The message to send.
      */
-    sendToUser <Key extends keyof EventType> (userId: string, event: Key, payload: EventType[Key]): void;
-
-    /**
-     * @desc Sends a message to specific clients in the channel.
-     * @param userIds - The ids of the users to send the message to.
-     * @param event - The event to send.
-     * @param payload - The message to send.
-     */
-    sendToUsers <Key extends keyof EventType> (userIds: string[], event: Key, payload: EventType[Key]): void;
+    broadcastTo<Key extends keyof EventType>(clientIds: string | string[], event: Key, payload: EventType[Key]): void;
 
     /**
      * @desc Bans a user from the channel.
-     * @param userId - The id of the user to ban.
-     * @param reason - The reason for the ban.
+     * @param {string} userId - The id of the user to ban.
+     * @param {string} reason - The reason for the ban.
      */
-    evictUser (userId: string, reason?: string): void;
+    evictUser(userId: string, reason?: string): void;
 
     /**
      * @desc tracks a user's presence in the channel
-     * @param userId - the id of the user to track
-     * @param presence - the presence of the user
+     * @param {string} userId - the id of the user to track
+     * @param {PondPresence} presence - the presence data to track
      */
-    trackPresence (userId: string, presence: PresenceType): void;
+    trackPresence(userId: string, presence: PresenceType): void;
 
     /**
      * @desc removes a user's presence from the channel
-     * @param userId - the id of the user to remove
+     * @param {string} userId - the id of the user to remove
      */
-    removePresence (userId: string): void;
+    removePresence(userId: string): void;
 
     /**
      * @desc updates a user's presence in the channel
-     * @param userId - the id of the user to update
-     * @param presence - the new presence of the user
+     * @param {string} userId - the id of the user to update
+     * @param {PondPresence} presence - the presence data to update
+     */
+    updatePresence(userId: string, presence: PresenceType): void;
+
+    /**
+     * @desc Subscribes a user to a channel.
+     * @param {string} userId - The id of the user.
+     * @param {string} channel - The channel to subscribe to.
      */
-    updatePresence (userId: string, presence: PresenceType): void;
+    subscribeTo(userId: string, channel: string): void;
+
+    /**
+     * @desc Unsubscribes a user from a channel.
+     * @param {string} userId - The id of the user.
+     * @param {string} channel - The channel to unsubscribe from.
+     */
+    unsubscribeFrom(userId: string, channel: string): void;
+}
+
+export declare class AbstractRequest<Path extends string, PresenceType extends PondPresence, AssignType extends PondAssigns> {
+    event: PondEvent<Path>;
+
+    channelName: string;
+
+    assigns: Record<string, AssignType>;
+
+    presence: Record<string, PresenceType>;
 }
 
 export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
@@ -249,6 +249,59 @@ export declare class JoinRequest<Path extends string, PresenceType extends PondP
     channel: Channel;
 }
 
+export declare class EventRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {
+    user: UserData<PresenceType, AssignType>;
+
+    channel: Channel;
+}
+
+export declare class ConnectionResponse {
+    /**
+     * @desc Whether the server has responded to the request
+     */
+    hasResponded: boolean;
+
+    /**
+     * @desc Assigns data to the user.
+     * @param {PondAssigns} assigns - The data to assign.
+     * @returns {ConnectionResponse} - The ConnectionResponse instance for chaining.
+     */
+    assign(assigns: PondAssigns): ConnectionResponse;
+
+    /**
+     * @desc Accepts the connection request to the endpoint.
+     */
+    accept(): void;
+
+    /**
+     * @desc Rejects the request with the given error message
+     * @param {string} message - The error message
+     * @param {number} errorCode - The error code
+     */
+    decline(message?: string, errorCode?: number): void;
+
+    /**
+     * @desc Emits a direct message to the client
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     */
+    reply(event: string, payload: PondMessage): ConnectionResponse;
+
+    /**
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     */
+    subscribeTo(channel: string): ConnectionResponse;
+
+    /**
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {ConnectionResponse} - The JoinResponse instance for chaining.
+     */
+    unsubscribeFrom(channel: string): ConnectionResponse;
+}
+
 export declare class JoinResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * @desc Whether the server has responded to the request
@@ -256,154 +309,170 @@ export declare class JoinResponse<EventType extends PondEventMap = PondEventMap,
     hasResponded: boolean;
 
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Assigns data to the client
+     * @param {PondAssigns} assigns - The data to assign
+     */
+    assign(assigns: AssignType): JoinResponse;
+
+    /**
+     * @desc Accepts the join request to the channel.
+     * @returns {JoinResponse} - The JoinResponse instance for chaining.
      */
-    accept (assigns?: AssignType): JoinResponse;
+    accept(): JoinResponse;
 
     /**
      * @desc Rejects the request and optionally assigns data to the client
-     * @param message - the error message
-     * @param errorCode - the error code
+     * @param {string} message - The error message
+     * @param {number} errorCode - The error code
      */
-    reject (message?: string, errorCode?: number): JoinResponse;
+    decline(message?: string, errorCode?: number): JoinResponse;
 
     /**
      * @desc Emits a direct message to the client
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     * @param {PondAssigns} assigns - The data to assign to the client
      */
-    send <Key extends keyof EventType> (event: Key, payload: EventType[Key], assigns?: AssignType): JoinResponse;
+    reply<Key extends keyof EventType>(event: Key, payload: EventType[Key], assigns?: AssignType): JoinResponse;
 
     /**
      * @desc Emits a message to all clients in the channel
-     * @param event - the event name
-     * @param payload - the payload to send
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
      */
-    broadcast <Key extends keyof EventType> (event: Key, payload: EventType[Key]): JoinResponse;
+    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinResponse;
 
     /**
      * @desc Emits a message to all clients in the channel except the sender
      * @param event - the event name
      * @param payload - the payload to send
      */
-    broadcastFromUser <Key extends keyof EventType> (event: Key, payload: EventType[Key]): JoinResponse;
+    broadcastFrom<Key extends keyof EventType>(event: Key, payload: EventType[Key]): JoinResponse;
 
     /**
      * @desc Emits a message to a specific set of clients
-     * @param event - the event name
-     * @param payload  - the payload to send
-     * @param userIds - the ids of the clients to send the message to
+     * @param {string} event - The event name
+     * @param {PondMessage} payload - The payload to send
+     * @param {string | string[]} userIds - The ids of the clients to send the message to
      */
-    sendToUsers <Key extends keyof EventType> (event: Key, payload: EventType[Key], userIds: string[]): JoinResponse;
+    broadcastTo<Key extends keyof EventType>(event: Key, payload: EventType[Key], userIds: string | string[]): JoinResponse;
 
     /**
      * @desc tracks the presence of a client
-     * @param presence - the presence data to track
+     * @param {PondPresence} presence - the presence data to track
      */
-    trackPresence (presence: PresenceType): JoinResponse;
+    trackPresence(presence: PresenceType): JoinResponse;
+
+    /**
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {JoinResponse} - The JoinResponse instance for chaining.
+     */
+    subscribeTo(channel: string): JoinResponse;
+
+    /**
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {JoinResponse} - The JoinResponse instance for chaining.
+     */
+    unsubscribeFrom(channel: string): JoinResponse;
 }
 
-export declare class ConnectionResponse {
+export declare class EventResponse<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * @desc Whether the server has responded to the request
      */
     hasResponded: boolean;
 
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Assigns data to the client.
+     * @param {PondAssigns} assigns - The data to assign to the client.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    accept (assigns?: PondAssigns): void;
+    assign(assigns: AssignType): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Rejects the request with the given error message
-     * @param message - the error message
-     * @param errorCode - the error code
+     * @desc Emits a direct message to the client.
+     * @param {string} event - The event name.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    reject (message?: string, errorCode?: number): void;
+    reply<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Emits a direct message to the client
-     * @param event - the event name
-     * @param payload - the payload to send
-     * @param assigns - the data to assign to the client
+     * @desc Sends a message to all clients in the channel.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    send (event: string, payload: PondMessage, assigns?: PondAssigns): void;
-}
+    broadcast<Event extends keyof EventType>(event: Event, payload: EventType[Event]): EventResponse<EventType, PresenceType, AssignType>;
 
-export declare class PondChannel <EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
-     * @desc Handles an event request made by a user
-     * @param event - The event to listen for
-     * @param handler - The handler to execute when the event is received
-     * @example
-     * pond.onEvent('echo', (request, response) => {
-     *     response.send('echo', {
-     *         message: request.event.payload,
-     *     });
-     * });
+     * @desc Sends a message to all clients in the channel except the client making the request.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    onEvent<Event extends string> (event: PondPath<Event>, handler: (request: EventRequest<Event, PresenceType, AssignType>, response: EventResponse<EventType, PresenceType, AssignType>) => void | Promise<void>): void;
+    broadcastFrom<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Broadcasts a message to all users in a channel
-     * @param event - The event to broadcast
-     * @param payload - The payload to send
-     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
-     * @example
-     * pond.broadcast('echo', {
-     *    message: 'Hello World',
-     *    timestamp: Date.now(),
-     *    channel: 'my_channel',
-     *});
+     * @desc Sends a message to a set of clients in the channel.
+     * @param {string} event - The event to send.
+     * @param {PondMessage} payload - The payload to send.
+     * @param {string | string[]} userIds - The ids of the clients to send the message to.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    broadcast <Key extends keyof EventType> (event: Key, payload: EventType[Key], channelName?: string): void;
+    broadcastTo<UserEvent extends keyof EventType>(event: UserEvent, payload: EventType[UserEvent], userIds: string | string[]): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Handles the leave event for a user, can occur when a user disconnects or leaves a channel, use this to clean up any resources
-     * @param callback - The callback to execute when a user leaves
+     * @desc Tracks a user's presence in the channel.
+     * @param {PondPresence} presence - The initial presence data.
+     * @param {string} userId - The id of the user to track.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    public onLeave (callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
+    trackPresence(presence: PresenceType, userId?: string): EventResponse<EventType, PresenceType, AssignType>;
 
     /**
-     * @desc Gets a channel by name
-     * @param channelName - The name of the channel to get
+     * @desc Updates a user's presence in the channel.
+     * @param {PondPresence} presence - The updated presence data.
+     * @param {string} userId - The id of the user to update.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    public getChannel (channelName: string): Channel<EventType, PresenceType, AssignType>;
-}
+    updatePresence(presence: PresenceType, userId?: string): EventResponse;
 
-export declare class PondSocket {
-    constructor (server?: HTTPServer, socketServer?: WebSocketServer);
+    /**
+     * @desc Removes a user's presence from the channel.
+     * @param {string} userId - The id of the user to remove.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
+     */
+    removePresence(userId?: string): EventResponse;
 
     /**
-     * @desc Specifies the port to listen on
-     * @param args - the arguments to pass to the server
+     * @desc Subscribes the client to a channel.
+     * @param {string} channel - The channel to subscribe to.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    listen (...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
+    subscribeTo(channel: string): EventResponse;
 
     /**
-     * @desc Closes the server
-     * @param callback - the callback to call when the server is closed
+     * @desc Unsubscribes the client from a channel.
+     * @param {string} channel - The channel to unsubscribe from.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    close (callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
+    unsubscribeFrom(channel: string): EventResponse;
 
     /**
-     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
-     * @param path - the pattern to accept || can also be a regex
-     * @param handler - the handler function to authenticate the socket
-     * @example
-     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
-     *    const token = req.query.token;
-     *    if (!token)
-     *       return res.reject('No token provided');
-     *    res.accept({
-     *       assign: {
-     *           token
-     *       }
-     *    });
-     * })
+     * @desc Evicts a user from the channel.
+     * @param {string} reason - The reason for the eviction.
+     * @param {string} userId - The id of the user to evict.
+     * @returns {EventResponse} - The EventResponse instance for chaining.
      */
-    createEndpoint<Path extends string> (path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>): Endpoint;
+    evictUser(reason: string, userId?: string): EventResponse;
+
+    /**
+     * @desc Closes the channel from the server side for all clients.
+     * @param {string} reason - The reason for closing the channel.
+     */
+    closeChannel(reason: string): void;
 }
+