@eleven-am/pondsocket 0.1.50 → 0.1.51

package/types.d.ts

@@ -1,360 +1,329 @@
-import { Server as HTTPServer, IncomingMessage, IncomingHttpHeaders } from 'http';
-import internal from 'stream';
-
-// eslint-disable-next-line import/no-unresolved
 import { Express } from 'express';
-import { WebSocketServer, WebSocket } from 'ws';
-
-import { ClientActions, PresenceEventTypes, ChannelState } from './enums';
-
-export type PondPath = string | RegExp;
-type NextFunction = () => void;
-export type JoinParams = Record<string, any>;
-type PondAssigns = Record<string, any>;
-export type PondMessage = Record<string, any>;
-export type PondPresence = Record<string, any>;
-export type EndpointHandler = (req: IncomingConnection, res: ConnectionResponse) => void;
-type SocketCache = Pick<RequestCache, 'socket' | 'clientId' | 'assigns'>;
-type AuthorizeMiddleware = (request: JoinRequest, response: JoinResponse) => void | Promise<void>;
-type SocketMiddlewareFunction = (req: IncomingMessage, socket: internal.Duplex, head: Buffer, next: NextFunction) => void;
-export type ChannelReceivers = 'all_users' | 'all_except_sender' | string[];
-export type ChannelEvent = Event | PresenceEvent;
-
-interface Event {
-    action: 'SYSTEM' | 'BROADCAST' | 'ERROR';
-    event: string;
-    payload: PondMessage;
-    channelName: string;
+import { Server as HTTPServer, IncomingHttpHeaders } from 'http';
+import { WebSocketServer } from 'ws';
+
+export type Unsubscribe = () => void;
+
+type IsParam<Path> = Path extends `:${infer Param}` ? Param : never;
+
+type FilteredParams<Path> = Path extends `${infer First}/${infer Second}`
+    ? IsParam<First> | FilteredParams<Second>
+    : IsParam<Path>
+
+export type Params<Path> = {
+    [Key in FilteredParams<Path>]: string
 }
-export interface ClientMessage {
-    action: ClientActions;
-    channelName: string;
-    event: string;
-    payload: Record<string, any>;
-    addresses?: ChannelReceivers;
+
+export type PondPath<Path extends string> = Path | RegExp;
+
+export type EventParams<Path> = {
+    query: Record<string, string>;
+    params: Params<Path>;
 }
-interface PresenceEvent {
-    action: 'PRESENCE';
-    event: PresenceEventTypes;
-    channelName: string;
-    payload: PresencePayload;
+
+type Primitives = number | string | boolean | null | undefined;
+
+type PondObject = {
+    [key: string]: Primitives | PondObject | PondObject[];
 }
-interface RequestCache {
-    clientId: string;
-    socket: WebSocket;
-    channelName: string;
-    assigns: PondAssigns;
-    joinParams: Record<string, any>;
-    params: Record<string, string>;
-    query: Record<string, string>;
+
+export type PondPresence = PondObject;
+export type PondMessage = PondObject;
+export type PondAssigns = PondObject;
+export type JoinParams = PondObject;
+
+export interface PresencePayload {
+    changed: PondPresence;
+    presence: PondPresence[];
 }
-interface UserAssigns {
-    [userId: string]: PondAssigns;
+
+export interface UserPresences {
+    [userId: string]: PondPresence;
 }
-interface UserData {
-    assigns: PondAssigns;
-    presence: PondPresence;
-    id: string;
+
+export interface UserAssigns {
+    [userId: string]: PondAssigns;
 }
-interface EventObject {
-    event: string;
-    params: Record<string, string>;
-    query: Record<string, string>;
+
+export type PondEvent<Path> = EventParams<Path> & {
     payload: PondMessage;
+    event: string;
 }
-interface IncomingConnection {
+
+export type IncomingConnection<Path> = EventParams<Path> & {
     id: string;
-    params: Record<string, string>;
-    query: Record<string, string>;
     headers: IncomingHttpHeaders;
     address: string;
 }
-interface UserPresences {
-    [userId: string]: PondPresence;
+
+export interface UserData {
+    assigns: PondAssigns;
+    presence: PondPresence;
+    id: string;
 }
 
-declare global {
-    // eslint-disable-next-line @typescript-eslint/no-namespace
-    namespace Express {
-        export interface Application {
-            upgrade(path: PondPath, handler: EndpointHandler): Endpoint;
-        }
-    }
+export enum ChannelState {
+    IDLE = 'IDLE',
+    JOINING = 'JOINING',
+    JOINED = 'JOINED',
+    STALLED = 'STALLED',
+    CLOSED = 'CLOSED',
 }
 
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-interface PondSocketExpressApp extends Express {
+export declare class AbstractRequest<Path extends string> {
+    event: PondEvent<Path>;
 
-    /**
-     * @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
-     *       }
-     *    });
-     * })
-     */
-    upgrade(path: PondPath, handler: EndpointHandler): Endpoint;
-}
-export type PondState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
-type Unsubscribe = () => void;
+    channelNme: string;
 
-export interface PresencePayload {
-    changed: PondPresence;
-    presence: PondPresence[];
+    assigns: UserAssigns;
+
+    presence: UserPresences;
 }
 
-export declare class Channel {
+export declare abstract class PondResponse {
     /**
-     * @desc Connects to the channel.
+     * @desc Rejects the request with the given error message
+     * @param message - the error message
+     * @param errorCode - the error code
+     * @param assigns - the data to assign to the client
      */
-    public join(): void;
+    abstract reject (message?: string, errorCode?: number, assigns?: PondAssigns): void;
 
     /**
-     * @desc Disconnects from the channel.
+     * @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
      */
-    public leave(): void;
+    abstract send (event: string, payload: PondMessage, assigns?: PondAssigns): void;
 
     /**
-     * @desc Monitors the channel for messages.
-     * @param event - The event to monitor.
-     * @param callback - The callback to call when a message is received.
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
      */
-    public onMessageEvent(event: string, callback: (message: PondMessage) => void): Unsubscribe;
+    abstract accept (assigns?: PondAssigns): void;
+}
 
-    /**
-     * @desc Monitors the channel for messages.
-     * @param callback - The callback to call when a message is received.
-     */
-    public onMessage(callback: (event: string, message: PondMessage) => void): Unsubscribe;
+export declare class EventRequest<Path extends string> extends AbstractRequest<Path> {
+    user: UserData;
+}
 
+export declare class EventResponse extends PondResponse {
     /**
-     * @desc Monitors the connection state of the channel.
-     * @param callback - The callback to call when the connection state changes.
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
      */
-    public onConnectionChange(callback: (connected: boolean) => void): Unsubscribe;
+    accept (assigns?: PondAssigns): EventResponse;
 
     /**
-     * @desc Monitors the channel state of the channel.
-     * @param callback - The callback to call when the connection state changes.
+     * @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
      */
-    public onChannelStateChange (callback: (connected: ChannelState) => void): Unsubscribe;
+    reject (message?: string, errorCode?: number, assigns?: PondAssigns): EventResponse;
 
     /**
-     * @desc Detects when clients join the channel.
-     * @param callback - The callback to call when a client joins the channel.
+     * @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
      */
-    public onJoin(callback: (presence: PondPresence) => void): Unsubscribe;
+    send (event: string, payload: PondMessage, assigns?: PondAssigns): void;
 
     /**
-     * @desc Detects when clients leave the channel.
-     * @param callback - The callback to call when a client leaves the channel.
+     * @desc Sends a message to all clients in the channel
+     * @param event - the event to send
+     * @param payload - the payload to send
      */
-    public onLeave(callback: (presence: PondPresence) => void): Unsubscribe;
+    broadcast (event: string, payload: PondMessage): EventResponse;
 
     /**
-     * @desc Detects when clients change their presence in the channel.
-     * @param callback - The callback to call when a client changes their presence in the channel.
+     * @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
      */
-    public onPresenceChange(callback: (presence: PresencePayload) => void): Unsubscribe;
+    broadcastFromUser (event: string, payload: PondMessage): EventResponse;
 
     /**
-     * @desc Sends a message to specific clients in the channel.
-     * @param event - The event to send.
-     * @param payload - The message to send.
-     * @param recipient - The clients to send the message to.
+     * @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
      */
-    public sendMessage(event: string, payload: PondMessage, recipient: string[]): void;
+    sendToUsers (event: string, payload: PondMessage, userIds: string[]): EventResponse;
 
     /**
-     * @desc Broadcasts a message to every other client in the channel except yourself.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @desc Tracks a user's presence in the channel
+     * @param presence - the initial presence data
+     * @param userId - the id of the user to track
      */
-    public broadcastFrom(event: string, payload: PondMessage): void;
+    trackPresence (presence: PondPresence, userId?: string): EventResponse;
 
     /**
-     * @desc Broadcasts a message to the channel, including yourself.
-     * @param event - The event to send.
-     * @param payload - The message to send.
+     * @desc Updates a user's presence in the channel
+     * @param presence - the updated presence data
+     * @param userId - the id of the user to update
      */
-    public broadcast(event: string, payload: PondMessage): void;
+    updatePresence (presence: PondPresence, userId?: string): EventResponse;
 
     /**
-     * @desc Gets the current connection state of the channel.
+     * @desc Removes a user's presence from the channel
+     * @param userId - the id of the user to remove
      */
-    public channelState: ChannelState;
+    unTrackPresence (userId?: string): EventResponse;
 
     /**
-     * @desc Gets the current presence of the channel.
+     * @desc Evicts a user from the channel
+     * @param reason - the reason for the eviction
+     * @param userId - the id of the user to evict,
      */
-    public getPresence(): PondPresence[];
+    evictUser (reason: string, userId?: string): void;
 
     /**
-     * @desc Monitors the presence of the channel.
-     * @param callback - The callback to call when the presence changes.
+     * @desc Closes the channel from the server side for all clients
+     * @param reason - the reason for closing the channel
      */
-    public onUsersChange(callback: (users: PondPresence[]) => void): Unsubscribe;
+    closeChannel (reason: string): void;
+}
 
+export declare class Channel {
     /**
      * @desc Gets the current connection state of the channel.
      */
-    public isConnected (): boolean;
-}
-
-declare class PondSocketClient {
-    constructor(endpoint: string, params?: Record<string, any>);
+    get channelState (): ChannelState;
 
     /**
-     * @desc Connects to the server and returns the socket.
+     * @desc Connects to the channel.
      */
-    public connect(backoff?: number): void;
+    join (): void;
 
     /**
-     * @desc Returns the current state of the socket.
+     * @desc Disconnects from the channel.
      */
-    public getState(): PondState;
+    leave (): void;
 
     /**
-     * @desc Disconnects the socket.
+     * @desc Monitors the channel for messages.
+     * @param callback - The callback to call when a message is received.
      */
-    public disconnect(): void;
+    onMessage (callback: (event: string, message: PondMessage) => void): Unsubscribe;
 
     /**
-     * @desc Creates a channel with the given name and params.
-     * @param name - The name of the channel.
-     * @param params - The params to send to the server.
+     * @desc Monitors the channel for messages.
+     * @param event - The event to monitor.
+     * @param callback - The callback to call when a message is received.
      */
-    public createChannel(name: string, params?: JoinParams): Channel;
+    onMessageEvent (event: string, callback: (message: PondMessage) => void): Unsubscribe;
 
     /**
-     * @desc Subscribes to the connection state.
-     * @param callback - The callback to call when the state changes.
+     * @desc Monitors the channel state of the channel.
+     * @param callback - The callback to call when the connection state changes.
      */
-    public onConnectionChange (callback: (state: PondState) => void): Unsubscribe;
-}
-
-declare class AbstractRequest {
-    get event (): EventObject;
-
-    get channelNme (): string;
-
-    get assigns (): UserAssigns;
-
-    get presence (): UserPresences;
-}
+    onChannelStateChange (callback: (connected: ChannelState) => void): Unsubscribe;
 
-declare class EventRequest extends AbstractRequest {
-    get user (): UserData;
-}
-
-declare class EventResponse {
     /**
-     * @desc Checks if the response has been sent
+     * @desc Detects when clients join the channel.
+     * @param callback - The callback to call when a client joins the channel.
      */
-    get responseSent (): boolean;
+    onJoin (callback: (presence: PondPresence) => void): Unsubscribe;
 
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Detects when clients leave the channel.
+     * @param callback - The callback to call when a client leaves the channel.
      */
-    accept (assigns?: PondAssigns): EventResponse;
+    onLeave (callback: (presence: PondPresence) => void): Unsubscribe;
 
     /**
-     * @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
+     * @desc Detects when clients change their presence in the channel.
+     * @param callback - The callback to call when a client changes their presence in the channel.
      */
-    reject (message?: string, errorCode?: number, assigns?: PondAssigns): EventResponse;
+    onPresenceChange (callback: (presence: PresencePayload) => void): Unsubscribe;
 
     /**
-     * @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 specific clients in the channel.
+     * @param event - The event to send.
+     * @param payload - The message to send.
+     * @param recipient - The clients to send the message to.
      */
-    send (event: string, payload: PondMessage, assigns?: PondAssigns): EventResponse;
+    sendMessage (event: string, payload: PondMessage, recipient: string[]): void;
 
     /**
-     * @desc Sends a message to all clients in the channel
-     * @param event - the event to send
-     * @param payload - the payload to send
+     * @desc Broadcasts a message to every other client in the channel except yourself.
+     * @param event - The event to send.
+     * @param payload - The message to send.
      */
-    broadcast (event: string, payload: PondMessage): EventResponse;
+    broadcastFrom (event: string, payload: PondMessage): void;
 
     /**
-     * @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 Broadcasts a message to the channel, including yourself.
+     * @param event - The event to send.
+     * @param payload - The message to send.
      */
-    broadcastFromUser (event: string, payload: PondMessage): EventResponse;
+    broadcast (event: string, payload: PondMessage): void;
 
     /**
-     * @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 Gets the current presence of the channel.
      */
-    sendToUsers (event: string, payload: PondMessage, userIds: string[]): EventResponse;
+    getPresence (): PondPresence[];
 
     /**
-     * @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 Monitors the presence of the channel.
+     * @param callback - The callback to call when the presence changes.
      */
-    trackPresence (presence: PondPresence, userId?: string): EventResponse;
+    onUsersChange (callback: (users: PondPresence[]) => void): Unsubscribe;
 
     /**
-     * @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 Gets the current connection state of the channel.
      */
-    updatePresence (presence: PondPresence, userId?: string): EventResponse;
+    isConnected (): boolean;
 
     /**
-     * @desc Removes a user's presence from the channel
-     * @param userId - the id of the user to remove
+     * @desc Monitors the connection state of the channel.
+     * @param callback - The callback to call when the connection state changes.
      */
-    unTrackPresence (userId?: string): EventResponse;
+    onConnectionChange (callback: (connected: boolean) => void): Unsubscribe;
+}
 
+export declare class Endpoint {
     /**
-     * @desc Evicts a user from the channel
-     * @param reason - the reason for the eviction
-     * @param userId - the id of the user to evict,
+     * @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
+     *
+     * @example
+     * const channel = endpoint.createChannel('/chat', (request, response) => {
+     *     if (request.user.assigns.admin)
+     *         response.accept();
+     *
+     *     else
+     *         response.reject('You are not an admin', 403);
+     * });
      */
-    evictUser (reason: string, userId?: string): void;
+    createChannel<Path extends string> (path: PondPath<Path>, handler: (request: JoinRequest<Path>, response: JoinResponse) => void | Promise<void>): PondChannel;
 
     /**
-     * @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 clients connected to this endpoint
+     * @param event - The event to broadcast
+     * @param payload - The payload to broadcast
      */
-    closeChannel (reason: string): void;
+    broadcast (event: string, payload: PondMessage): void;
 
     /**
-     * @desc Resolves the request as sent with no further action
+     * @desc Closes specific clients connected to this endpoint
+     * @param clientIds - The id for the client / clients to close
      */
-    end (): void;
+    closeConnection (clientIds: string | string[]): void;
 }
 
-declare class JoinRequest extends AbstractRequest {
-    get joinParams (): JoinParams;
+export declare class JoinRequest<Path extends string> extends AbstractRequest<Path> {
+    joinParams: JoinParams;
 
-    get user (): UserData;
-
-    get event (): EventObject;
+    user: UserData;
 }
 
-declare class JoinResponse {
-    get responseSent (): boolean;
+export declare class JoinResponse extends PondResponse {
+    #private;
 
     /**
      * @desc Accepts the request and optionally assigns data to the client
@@ -404,28 +373,32 @@ declare class JoinResponse {
      * @param presence - the presence data to track
      */
     trackPresence (presence: PondPresence): JoinResponse;
+}
 
+export declare class ConnectionResponse extends PondResponse {
     /**
-     * @desc Resolves the request as sent with no further action
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
      */
-    end (): void;
-}
+    accept (assigns?: PondAssigns): void;
 
-declare class PondChannel {
     /**
-     * @desc Authorize a user to join a channel
-     * @param handler - The handler to authorize the user
-     * @example
-     * const pond = new PondChannelEngine();
-     * pond.onJoinRequest((request, response) => {
-     *     if (request.user.assigns.admin)
-     *          response.accept();
-     *     else
-     *         response.reject('You are not an admin', 403);
-     * });
+     * @desc Rejects the request with the given error message
+     * @param message - the error message
+     * @param errorCode - the error code
+     */
+    reject (message?: string, errorCode?: number): void;
+
+    /**
+     * @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
      */
-    onJoinRequest (handler: AuthorizeMiddleware): void;
+    send (event: string, payload: PondMessage, assigns?: PondAssigns): void;
+}
 
+export declare class PondChannel {
     /**
      * @desc Handles an event request made by a user
      * @param event - The event to listen for
@@ -437,7 +410,7 @@ declare class PondChannel {
      *     });
      * });
      */
-    onEvent (event: PondPath, handler: (request: EventRequest, response: EventResponse) => void | Promise<void>): void;
+    onEvent<Event extends string> (event: PondPath<Event>, handler: (request: EventRequest<Event>, response: EventResponse) => void | Promise<void>): void;
 
     /**
      * @desc Broadcasts a message to all users in a channel
@@ -454,84 +427,41 @@ declare class PondChannel {
     broadcast (event: string, payload: PondMessage, channelName?: string): void;
 }
 
-declare class ConnectionResponse {
-    /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
-     */
-    accept (assigns?: PondAssigns): void;
-
-    /**
-     * @desc Rejects the request with the given error message
-     * @param message - the error message
-     * @param errorCode - the error code
-     */
-    reject (message?: string, errorCode?: number): void;
+export declare class PondSocket {
+    constructor (server?: HTTPServer, socketServer?: WebSocketServer);
 
     /**
-     * @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 Specifies the port to listen on
+     * @param args - the arguments to pass to the server
      */
-    send (event: string, payload: PondMessage, assigns?: PondAssigns): void;
+    listen (...args: any[]): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
     /**
-     * @desc Resolves the request as sent with no further action
+     * @desc Closes the server
+     * @param callback - the callback to call when the server is closed
      */
-    end (): void;
-}
+    close (callback?: () => void): HTTPServer<typeof import('http').IncomingMessage, typeof import('http').ServerResponse>;
 
-declare class Endpoint {
     /**
-     * @desc Adds a new PondChannel to this path on this endpoint
-     * @param path - The path to add the channel to
-     * @param channel - The channel to add
-     *
+     * @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
-     * endpoint.addChannel('/chat', pondChannelInstance);
-     */
-    addChannel (path: PondPath, channel: PondChannel): void;
-
-    /**
-     * @desc List all clients connected to this endpoint
-     */
-    listConnections (): string[];
-
-    /**
-     * @desc Gets all clients connected to this endpoint
-     */
-    getClients (): SocketCache[];
-
-    /**
-     * @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;
-
-    /**
-     * @desc Closes specific clients connected to this endpoint
-     * @param clientIds - The id for the client / clients to close
+     * 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
+     *       }
+     *    });
+     * })
      */
-    closeConnection (clientIds: string | string[]): void;
+    createEndpoint<Path extends string> (path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>): Endpoint;
 }
 
-declare class PondSocket {
-    constructor (server?: HTTPServer, socketServer?: WebSocketServer);
-
-    /**
-     * @desc Specifies the port to listen on
-     * @param port - the port to listen on
-     * @param callback - the callback to call when the server is listening
-     */
-    listen (port: number, callback: (port?: number) => void): HTTPServer<typeof IncomingMessage, typeof import('http').ServerResponse>;
-
-    /**
-     * @desc Closes the server
-     * @param callback - the callback to call when the server is closed
-     */
-    close (callback?: () => void): HTTPServer<typeof IncomingMessage, typeof import('http').ServerResponse>;
+interface PondSocketExpressApp extends Express {
 
     /**
      * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
@@ -549,19 +479,40 @@ declare class PondSocket {
      *    });
      * })
      */
-    createEndpoint (path: PondPath, handler: EndpointHandler): Endpoint;
+    upgrade<Path extends string> (path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>): Endpoint;
+}
+
+export declare class PondClient {
+    constructor (endpoint: string, params?: Record<string, any>);
+
+    /**
+     * @desc Connects to the server and returns the socket.
+     */
+    connect (backoff?: number): void;
+
+    /**
+     * @desc Returns the current state of the socket.
+     */
+    getState (): boolean;
 
     /**
-     * @desc Adds a middleware function to the socket server
-     * @param middleware - the middleware function to add
+     * @desc Disconnects the socket.
+     */
+    disconnect (): void;
+
+    /**
+     * @desc Creates a channel with the given name and params.
+     * @param name - The name of the channel.
+     * @param params - The params to send to the server.
+     */
+    createChannel (name: string, params?: JoinParams): Channel;
+
+    /**
+     * @desc Subscribes to the connection state.
+     * @param callback - The callback to call when the state changes.
      */
-    use (middleware: SocketMiddlewareFunction): void;
+    onConnectionChange (callback: (state: boolean) => void): Unsubscribe;
 }
 
-/**
- * @desc Creates a pond socket server
- * @param app - The Express app to be used by the server
- * @constructor
- */
-declare const PondSocketFromExpress: (app: Express) => PondSocketExpressApp;
+declare const pondSocket: (app: Express) => PondSocketExpressApp;