@eleven-am/pondsocket 0.1.216 → 0.1.217

package/abstracts/types.d.ts

@@ -1,7 +1,7 @@
 import { IncomingHttpHeaders } from 'http';
 import { IncomingMessage } from 'node:http';
 import internal from 'node:stream';
-import { ChannelEvent, EventParams, JoinParams, PondAssigns, PondMessage, ServerActions, SystemSender, Unsubscribe, UserData } from '@eleven-am/pondsocket-common';
+import { ChannelEvent, AnyPondSchema, AssignsOf, EventParams, EventsOf, JoinParamsOf, PondAssigns, PondEventMap, PondMessage, PondPresence, ServerActions, SystemSender, Unsubscribe, UserData } from '@eleven-am/pondsocket-common';
 import { WebSocket, WebSocketServer } from 'ws';
 import { ConnectionContext } from '../contexts/connectionContext';
 import { EventContext } from '../contexts/eventContext';
@@ -17,10 +17,13 @@ export interface SocketRequest {
     headers: IncomingHttpHeaders;
     address: string;
 }
-export type ConnectionHandler<Path extends string> = (ctx: ConnectionContext<Path>, next: NextFunction) => void | Promise<void>;
-export type AuthorizationHandler<Path extends string> = (ctx: JoinContext<Path>, next: NextFunction) => void | Promise<void>;
-export type EventHandler<Path extends string> = (ctx: EventContext<Path>, next: NextFunction) => void | Promise<void>;
-export type OutgoingEventHandler<Event extends string> = (event: OutgoingContext<Event>, next: NextFunction) => PondMessage | Promise<PondMessage> | void | Promise<void>;
+export type EventPayload<EventMap extends PondEventMap, Event extends keyof EventMap> = EventMap[Event] extends [PondMessage, PondMessage] ? EventMap[Event][0] : EventMap[Event];
+export type EventResponse<EventMap extends PondEventMap, Event extends keyof EventMap> = EventMap[Event] extends [PondMessage, PondMessage] ? EventMap[Event][1] : PondMessage;
+export type EventKey<Schema extends AnyPondSchema> = Extract<keyof EventsOf<Schema>, string>;
+export type ConnectionHandler<Path extends string> = (ctx: ConnectionContext<Path>, next: NextFunction) => unknown | Promise<unknown>;
+export type AuthorizationHandler<Path extends string, Schema extends AnyPondSchema = AnyPondSchema> = (ctx: JoinContext<Path, Schema>, next: NextFunction) => unknown | Promise<unknown>;
+export type EventHandler<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, Event extends EventKey<Schema> = EventKey<Schema>> = (ctx: EventContext<Path, Schema, Event>, next: NextFunction) => unknown | Promise<unknown>;
+export type OutgoingEventHandler<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, Event extends EventKey<Schema> = EventKey<Schema>> = (event: OutgoingContext<Path, Schema, Event>, next: NextFunction) => EventPayload<EventsOf<Schema>, Event> | Promise<EventPayload<EventsOf<Schema>, Event>> | void | Promise<void>;
 export interface ConnectionParams {
     head: Buffer;
     socket: internal.Duplex;
@@ -39,10 +42,10 @@ export interface ConnectionResponseOptions {
     params: ConnectionParams;
     webSocketServer: WebSocketServer;
 }
-export interface JoinRequestOptions<Path extends string> {
+export interface JoinRequestOptions<Path extends string, Schema extends AnyPondSchema = AnyPondSchema> {
     clientId: string;
-    assigns: PondAssigns;
-    joinParams: JoinParams;
+    assigns: AssignsOf<Schema>;
+    joinParams: JoinParamsOf<Schema>;
     params: EventParams<Path>;
 }
 export interface RequestCache extends SocketCache {
@@ -59,7 +62,7 @@ export type BroadcastEvent = Omit<InternalChannelEvent, 'action' | 'payload' | '
     payload: PondMessage;
 };
 export interface LeaveEvent {
-    user: UserData;
+    user: UserData<PondPresence, PondAssigns>;
     channel: Channel;
 }
 export type LeaveCallback = (event: LeaveEvent) => void;

package/contexts/baseContext.d.ts

@@ -1,18 +1,23 @@
-import { ChannelReceivers, EventParams, PondEvent, PondMessage, PondObject, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, AssignsOf, EventParams, EventPayload, EventsOf, PondEvent, PondMessage, PondObject, PresenceOf, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from '../engines/channelEngine';
 import { Channel } from '../wrappers/channel';
-export declare abstract class BaseContext<Path extends string> {
+export declare abstract class BaseContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>, Payload extends PondMessage = EventPayload<EventsOf<Schema>, EventName>> {
     #private;
-    constructor(engine: ChannelEngine, params: EventParams<Path>, event: string, payload: PondMessage, sender: string);
-    get event(): PondEvent<Path>;
+    protected constructor(engine: ChannelEngine, params: EventParams<Path>, event: string, payload: Payload, sender: string);
+    get event(): PondEvent<Path> & {
+        event: EventName;
+        payload: Payload;
+    };
+    get query(): EventParams<Path>['query'];
+    get params(): EventParams<Path>['params'];
     get channelName(): string;
-    get channel(): Channel;
-    get presences(): UserPresences;
-    get assigns(): UserAssigns;
-    get user(): import("@eleven-am/pondsocket-common").UserData<PondObject, PondObject>;
-    broadcast(event: string, payload: PondMessage): this;
-    broadcastFrom(event: string, payload: PondMessage): this;
-    broadcastTo(event: string, payload: PondMessage, userIds: string | string[]): this;
+    get channel(): Channel<Schema>;
+    get presences(): UserPresences<PresenceOf<Schema>>;
+    get assigns(): UserAssigns<AssignsOf<Schema>>;
+    get user(): import("@eleven-am/pondsocket-common").UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>, userIds: string | string[]): this;
     protected abstract _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
     protected get engine(): ChannelEngine;
     protected get sender(): string;

package/contexts/baseContext.js

@@ -36,6 +36,12 @@ class BaseContext {
             payload: __classPrivateFieldGet(this, _BaseContext_payload, "f"),
         };
     }
+    get query() {
+        return __classPrivateFieldGet(this, _BaseContext_params, "f").query;
+    }
+    get params() {
+        return __classPrivateFieldGet(this, _BaseContext_params, "f").params;
+    }
     get channelName() {
         return __classPrivateFieldGet(this, _BaseContext_engine, "f").name;
     }

package/contexts/connectionContext.d.ts

@@ -54,7 +54,7 @@ export declare class ConnectionContext<Path extends string> {
     /**
      * Accepts the connection request
      */
-    accept(): ConnectionContext<Path>;
+    accept(assigns?: PondAssigns): ConnectionContext<Path>;
     /**
      * Declines the connection request
      */

package/contexts/connectionContext.js

@@ -115,7 +115,10 @@ class ConnectionContext {
     /**
      * Accepts the connection request
      */
-    accept() {
+    accept(assigns) {
+        if (assigns) {
+            this.assign(assigns);
+        }
         __classPrivateFieldGet(this, _ConnectionContext_instances, "m", _ConnectionContext_performChecks).call(this);
         __classPrivateFieldGet(this, _ConnectionContext_webSocketServer, "f").handleUpgrade(__classPrivateFieldGet(this, _ConnectionContext_params, "f").request, __classPrivateFieldGet(this, _ConnectionContext_params, "f").socket, __classPrivateFieldGet(this, _ConnectionContext_params, "f").head, (ws) => {
             const cache = {

package/contexts/eventContext.d.ts

@@ -1,15 +1,16 @@
-import { ChannelReceivers, EventParams, PondAssigns, PondMessage, PondObject, PondPresence } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, AssignsOf, EventParams, EventPayload, EventsOf, PondObject, PresenceOf } from '@eleven-am/pondsocket-common';
 import { BaseContext } from './baseContext';
 import { BroadcastEvent } from '../abstracts/types';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class EventContext<Path extends string> extends BaseContext<Path> {
+export declare class EventContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> extends BaseContext<Path, Schema, EventName, EventPayload<EventsOf<Schema>, EventName>> {
     #private;
     constructor(event: BroadcastEvent, params: EventParams<Path>, engine: ChannelEngine);
-    assign(assigns: PondAssigns): EventContext<Path>;
-    reply(event: string, payload: PondMessage): this;
-    trackPresence(presence: PondPresence, userId?: string): EventContext<Path>;
-    updatePresence(presence: PondPresence, userId?: string): EventContext<Path>;
-    evictUser(reason: string, userId?: string): EventContext<Path>;
-    removePresence(userId?: string): EventContext<Path>;
+    get payload(): EventPayload<EventsOf<Schema>, EventName>;
+    assign(assigns: Partial<AssignsOf<Schema>>): EventContext<Path, Schema, EventName>;
+    reply<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    trackPresence(presence: PresenceOf<Schema>, userId?: string): EventContext<Path, Schema, EventName>;
+    updatePresence(presence: Partial<PresenceOf<Schema>>, userId?: string): EventContext<Path, Schema, EventName>;
+    evictUser(reason: string, userId?: string): EventContext<Path, Schema, EventName>;
+    removePresence(userId?: string): EventContext<Path, Schema, EventName>;
     protected _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
 }

package/contexts/eventContext.js

@@ -23,6 +23,9 @@ class EventContext extends baseContext_1.BaseContext {
         __classPrivateFieldSet(this, _EventContext_event, event, "f");
         __classPrivateFieldSet(this, _EventContext_requestId, event.requestId, "f");
     }
+    get payload() {
+        return __classPrivateFieldGet(this, _EventContext_event, "f").payload;
+    }
     assign(assigns) {
         this.channel.updateAssigns(__classPrivateFieldGet(this, _EventContext_event, "f").sender, assigns);
         return this;

package/contexts/joinContext.d.ts

@@ -1,17 +1,17 @@
-import { ChannelReceivers, JoinParams, PondAssigns, PondMessage, PondObject, PondPresence, UserData } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, AssignsOf, EventsOf, JoinParamsOf, PondMessage, PondObject, PresenceOf, UserData } from '@eleven-am/pondsocket-common';
 import { BaseContext } from './baseContext';
 import { JoinRequestOptions, RequestCache } from '../abstracts/types';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class JoinContext<Path extends string> extends BaseContext<Path> {
+export declare class JoinContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema> extends BaseContext<Path, Schema, Extract<keyof EventsOf<Schema>, string>, JoinParamsOf<Schema>> {
     #private;
-    constructor(options: JoinRequestOptions<Path>, engine: ChannelEngine, user: RequestCache);
-    get user(): UserData;
-    get joinParams(): JoinParams;
+    constructor(options: JoinRequestOptions<Path, Schema>, engine: ChannelEngine, user: RequestCache);
+    get user(): UserData<PresenceOf<Schema>, AssignsOf<Schema>>;
+    get joinParams(): JoinParamsOf<Schema>;
     get hasResponded(): boolean;
-    accept(): JoinContext<Path>;
-    decline(message?: string, errorCode?: number): JoinContext<Path>;
-    assign(assigns: PondAssigns): JoinContext<Path>;
-    reply(event: string, payload: PondMessage): JoinContext<Path>;
-    trackPresence(presence: PondPresence): JoinContext<Path>;
+    accept(assigns?: Partial<AssignsOf<Schema>>): JoinContext<Path, Schema>;
+    decline(message?: string, errorCode?: number): JoinContext<Path, Schema>;
+    assign(assigns: Partial<AssignsOf<Schema>>): JoinContext<Path, Schema>;
+    reply(event: string, payload: PondMessage): JoinContext<Path, Schema>;
+    trackPresence(presence: PresenceOf<Schema>): JoinContext<Path, Schema>;
     protected _sendMessageToRecipients(recipient: ChannelReceivers, event: string, payload: PondObject): void;
 }

package/contexts/joinContext.js

@@ -44,8 +44,11 @@ class JoinContext extends baseContext_1.BaseContext {
     get hasResponded() {
         return __classPrivateFieldGet(this, _JoinContext_executed, "f");
     }
-    accept() {
+    accept(assigns) {
         var _a;
+        if (assigns) {
+            this.assign(assigns);
+        }
         __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_performChecks).call(this);
         const onMessage = this.engine.parent.parent.sendMessage.bind(this.engine.parent.parent, __classPrivateFieldGet(this, _JoinContext_user, "f").socket);
         const subscription = this.engine.addUser(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f"), onMessage);

package/contexts/outgoingContext.d.ts

@@ -1,10 +1,10 @@
-import { ChannelReceivers, Event, EventParams, PondMessage, PondObject } from '@eleven-am/pondsocket-common';
+import { ChannelReceivers, AnyPondSchema, Event, EventParams, EventPayload, EventsOf, PondObject } from '@eleven-am/pondsocket-common';
 import { BaseContext } from './baseContext';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class OutgoingContext<Path extends string> extends BaseContext<Path> {
+export declare class OutgoingContext<Path extends string, Schema extends AnyPondSchema = AnyPondSchema, EventName extends Extract<keyof EventsOf<Schema>, string> = Extract<keyof EventsOf<Schema>, string>> extends BaseContext<Path, Schema, EventName, EventPayload<EventsOf<Schema>, EventName>> {
     #private;
     constructor(event: Event, params: EventParams<Path>, engine: ChannelEngine, userid: string);
-    get payload(): PondMessage;
+    get payload(): EventPayload<EventsOf<Schema>, EventName>;
     /**
      * Blocks the outgoing context, preventing further processing of the event.
      */
@@ -18,7 +18,7 @@ export declare class OutgoingContext<Path extends string> extends BaseContext<Pa
      * Transforms the outgoing context with a new payload.
      * @param payload - The new payload to set for the context.
      */
-    transform(payload: PondMessage): this;
+    transform(payload: EventPayload<EventsOf<Schema>, EventName>): this;
     /**
      * Updates the parameters of the outgoing context.
      * @param params - The new parameters to set for the context.

package/engines/endpointEngine.d.ts

@@ -1,4 +1,4 @@
-import { ChannelEvent, PondPath } from '@eleven-am/pondsocket-common';
+import { ChannelEvent, AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
 import { WebSocket } from 'ws';
 import { AuthorizationHandler, SocketCache } from '../abstracts/types';
 import { IDistributedBackend } from '../types';
@@ -10,7 +10,7 @@ export declare class EndpointEngine {
     /**
      * Creates a new channel on a specified path
      */
-    createChannel<Path extends string>(path: PondPath<Path>, handler: AuthorizationHandler<Path>): PondChannel;
+    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): PondChannel<Schema>;
     /**
      * Gets all connected clients
      */

package/engines/endpointEngine.js

@@ -52,7 +52,7 @@ class EndpointEngine {
                 };
                 const channel = lobbyEngine.getOrCreateChannel(user.channelName);
                 const context = new joinContext_1.JoinContext(options, channel, user);
-                return handler(context, next);
+                return Promise.resolve(handler(context, next)).then(() => undefined);
             }
             next();
         });

package/engines/lobbyEngine.d.ts

@@ -1,4 +1,4 @@
-import { Event, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, Event, EventsOf, PondPath } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from './channelEngine';
 import { EndpointEngine } from './endpointEngine';
 import { Middleware } from '../abstracts/middleware';
@@ -20,11 +20,11 @@ export declare class LobbyEngine {
     /**
      * Attaches a handler for a specific event pattern
      */
-    onEvent<Event extends string>(event: PondPath<Event>, handler: EventHandler<Event>): void;
+    onEvent<Schema extends AnyPondSchema, Path extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Path>, handler: EventHandler<Path, Schema, Path>): void;
     /**
      * Attaches a handler for outgoing events
      */
-    handleOutgoingEvent<Event extends string>(event: PondPath<Event>, handler: OutgoingEventHandler<Event>): void;
+    handleOutgoingEvent<Schema extends AnyPondSchema, Path extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Path>, handler: OutgoingEventHandler<Path, Schema, Path>): void;
     /**
      * Processes an outgoing event, applying middleware and returning a new event
      * @param event - The channel event to process

package/engines/lobbyEngine.js

@@ -56,7 +56,7 @@ class LobbyEngine {
                 return next();
             }
             const context = new eventContext_1.EventContext(requestEvent, params, channel);
-            return handler(context, next);
+            return Promise.resolve(handler(context, next)).then(() => undefined);
         });
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.216",
+  "version": "0.1.217",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -43,7 +43,9 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.38",
+    "@eleven-am/pondsocket-common": "^0.0.39",
+    "@types/node": "^25.3.3",
+    "@types/ws": "^8.18.1",
     "redis": "^5.12.1",
     "ws": "^8.20.1"
   },

package/server/server.js

@@ -93,7 +93,7 @@ class PondSocket {
                 webSocketServer: __classPrivateFieldGet(this, _PondSocket_socketServer, "f"),
             };
             const context = new connectionContext_1.ConnectionContext(request, newParams);
-            return handler(context, next);
+            return Promise.resolve(handler(context, next)).then(() => undefined);
         });
         return new endpoint_1.Endpoint(endpoint);
     }

package/wrappers/channel.d.ts

@@ -1,32 +1,32 @@
-import { PondMessage, PondAssigns, PondPresence } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, AssignsOf, EventsOf, EventPayload, PresenceOf, UserData, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from '../engines/channelEngine';
-export declare class Channel {
+export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     #private;
     constructor(engine: ChannelEngine);
     /**
      * Gets a user's data
      */
-    getUserData(userId: string): import("@eleven-am/pondsocket-common").UserData<import("@eleven-am/pondsocket-common").PondObject, import("@eleven-am/pondsocket-common").PondObject>;
+    getUserData(userId: string): UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null;
     /**
      * Gets all presence data
      */
-    getPresences(): import("@eleven-am/pondsocket-common").UserPresences;
+    getPresences(): UserPresences<PresenceOf<Schema>>;
     /**
      * Gets all assigns data
      */
-    getAssigns(): import("@eleven-am/pondsocket-common").UserAssigns;
+    getAssigns(): UserAssigns<AssignsOf<Schema>>;
     /**
      * Broadcasts a message to all users
      */
-    broadcast(event: string, payload: PondMessage): this;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
     /**
      * Broadcasts a message from a specific user to all others
      */
-    broadcastFrom(userId: string, event: string, payload: PondMessage): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
     /**
      * Broadcasts a message to specific users
      */
-    broadcastTo(userIds: string | string[], event: string, payload: PondMessage): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
     /**
      * Kicks a user from the channel
      */
@@ -34,11 +34,11 @@ export declare class Channel {
     /**
      * Tracks a user's presence
      */
-    trackPresence(userId: string, presence: PondPresence): this;
+    trackPresence(userId: string, presence: PresenceOf<Schema>): this;
     /**
      * Updates a user's presence
      */
-    updatePresence(userId: string, presence: PondPresence): this;
+    updatePresence(userId: string, presence: Partial<PresenceOf<Schema>>): this;
     /**
      * Removes a user's presence
      */
@@ -46,9 +46,9 @@ export declare class Channel {
     /**
      * Adds or updates a user's presence
      */
-    upsertPresence(userId: string, presence: PondPresence): this;
+    upsertPresence(userId: string, presence: PresenceOf<Schema>): this;
     /**
      * Updates a user's assigns
      */
-    updateAssigns(userId: string, assigns: PondAssigns): this;
+    updateAssigns(userId: string, assigns: Partial<AssignsOf<Schema>>): this;
 }

package/wrappers/endpoint.d.ts

@@ -1,10 +1,10 @@
-import { PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
 import { AuthorizationHandler } from '../abstracts/types';
 import { EndpointEngine } from '../engines/endpointEngine';
 export declare class Endpoint {
     #private;
     constructor(engine: EndpointEngine);
-    createChannel<Path extends string>(path: PondPath<Path>, handler: AuthorizationHandler<Path>): import("./pondChannel").PondChannel;
+    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): import("./pondChannel").PondChannel<Schema>;
     closeConnection(clientIds: string | string[]): void;
     getClients(): import("ws").WebSocket[];
 }

package/wrappers/pondChannel.d.ts

@@ -1,15 +1,15 @@
-import { PondMessage, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, EventPayload, EventsOf, PondPath } from '@eleven-am/pondsocket-common';
 import { Channel } from './channel';
 import { EventHandler, LeaveCallback, OutgoingEventHandler } from '../abstracts/types';
 import { LobbyEngine } from '../engines/lobbyEngine';
-export declare class PondChannel {
+export declare class PondChannel<Schema extends AnyPondSchema = AnyPondSchema> {
     #private;
     constructor(lobby: LobbyEngine);
-    onEvent<Event extends string>(event: PondPath<Event>, handler: EventHandler<Event>): PondChannel;
-    onLeave(callback: LeaveCallback): PondChannel;
-    handleOutgoingEvent<Event extends string>(event: PondPath<Event>, handler: OutgoingEventHandler<Event>): this;
-    getChannel(channelName: string): Channel | null;
-    broadcast(channelName: string, event: string, payload: PondMessage): PondChannel;
-    broadcastFrom(channelName: string, userId: string, event: string, payload: PondMessage): PondChannel;
-    broadcastTo(channelName: string, userIds: string | string[], event: string, payload: PondMessage): PondChannel;
+    onEvent<Event extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Event>, handler: EventHandler<Event, Schema, Event>): PondChannel<Schema>;
+    onLeave(callback: LeaveCallback): PondChannel<Schema>;
+    handleOutgoingEvent<Event extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Event>, handler: OutgoingEventHandler<Event, Schema, Event>): this;
+    getChannel(channelName: string): Channel<Schema> | null;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
 }