@colyseus/sdk 0.17.0

package/lib/Client.d.ts

@@ -0,0 +1,92 @@
+import type { matchMaker, SDKTypes, Room as ServerRoom } from '@colyseus/core';
+import { Room } from './Room.ts';
+import { SchemaConstructor } from './serializer/SchemaSerializer.ts';
+import { HTTP } from './HTTP.ts';
+import { Auth } from './Auth.ts';
+export type JoinOptions = any;
+export type ISeatReservation = matchMaker.ISeatReservation;
+export declare class MatchMakeError extends Error {
+    code: number;
+    constructor(message: string, code: number);
+}
+export interface EndpointSettings {
+    hostname: string;
+    secure: boolean;
+    port?: number;
+    pathname?: string;
+    searchParams?: string;
+    protocol?: "ws" | "h3";
+}
+export interface ClientOptions {
+    headers?: {
+        [id: string]: string;
+    };
+    urlBuilder?: (url: URL) => string;
+    protocol?: "ws" | "h3";
+}
+export interface LatencyOptions {
+    /** "ws" for WebSocket, "h3" for WebTransport (default: "ws") */
+    protocol?: "ws" | "h3";
+    /** Number of pings to send (default: 1). Returns the average latency when > 1. */
+    pingCount?: number;
+}
+export declare class ColyseusSDK<ServerType extends SDKTypes = any> {
+    static VERSION: string;
+    /**
+     * The HTTP client to make requests to the server.
+     */
+    http: HTTP<ServerType['~routes']>;
+    /**
+     * The authentication module to authenticate into requests and rooms.
+     */
+    auth: Auth;
+    /**
+     * The settings used to connect to the server.
+     */
+    settings: EndpointSettings;
+    protected urlBuilder: (url: URL) => string;
+    constructor(settings?: string | EndpointSettings, options?: ClientOptions);
+    /**
+     * Select the endpoint with the lowest latency.
+     * @param endpoints Array of endpoints to select from.
+     * @param options Client options.
+     * @param latencyOptions Latency measurement options (protocol, pingCount).
+     * @returns The client with the lowest latency.
+     */
+    static selectByLatency<ServerType extends SDKTypes = any>(endpoints: Array<string | EndpointSettings>, options?: ClientOptions, latencyOptions?: LatencyOptions): Promise<ColyseusSDK<ServerType>>;
+    joinOrCreate<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    joinOrCreate<RoomType extends typeof ServerRoom>(roomName: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    joinOrCreate<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    create<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    create<RoomType extends typeof ServerRoom>(roomName: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    create<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    join<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    join<RoomType extends typeof ServerRoom>(roomName: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    join<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    joinById<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    joinById<RoomType extends typeof ServerRoom>(roomId: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    joinById<State = any>(roomId: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    /**
+     * Re-establish connection with a room this client was previously connected to.
+     *
+     * @param reconnectionToken The `room.reconnectionToken` from previously connected room.
+     * @param rootSchema (optional) Concrete root schema definition
+     * @returns Promise<Room>
+     */
+    reconnect<R extends keyof ServerType['~rooms']>(reconnectionToken: string, roomName?: R): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    reconnect<RoomType extends typeof ServerRoom>(reconnectionToken: string, rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    reconnect<State = any>(reconnectionToken: string, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    consumeSeatReservation<T>(response: ISeatReservation, rootSchema?: SchemaConstructor<T>): Promise<Room<any, T>>;
+    /**
+     * Create a new connection with the server, and measure the latency.
+     * @param options Latency measurement options (protocol, pingCount).
+     */
+    getLatency(options?: LatencyOptions): Promise<number>;
+    protected createMatchMakeRequest<T>(method: string, roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<T>): Promise<Room<any, T>>;
+    protected createRoom<T>(roomName: string, rootSchema?: SchemaConstructor<T>): Room<any, T>;
+    protected buildEndpoint(seatReservation: ISeatReservation, options?: any): string;
+    protected getHttpEndpoint(segments?: string): string;
+    protected getEndpointPort(): string;
+}
+export declare const Client: typeof ColyseusSDK;
+export type Client = InstanceType<typeof ColyseusSDK>;

package/lib/Connection.d.ts

@@ -0,0 +1,17 @@
+import type { ITransport, ITransportEventMap } from "./transport/ITransport.ts";
+export declare class Connection implements ITransport {
+    transport: ITransport;
+    events: ITransportEventMap;
+    url?: string;
+    options?: any;
+    constructor(protocol?: string);
+    connect(url: string, options?: any): void;
+    send(data: Buffer | Uint8Array): void;
+    sendUnreliable(data: Buffer | Uint8Array): void;
+    reconnect(queryParams: {
+        reconnectionToken: string;
+        skipHandshake?: boolean;
+    }): void;
+    close(code?: number, reason?: string): void;
+    get isOpen(): boolean;
+}

package/lib/HTTP.d.ts

@@ -0,0 +1,113 @@
+import type { Router, HasRequiredKeys, Prettify, UnionToIntersection, Endpoint, HTTPMethod } from "@colyseus/better-call";
+import { ColyseusSDK } from "./Client.ts";
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsAnyOrAnyIndexed<T> = IsAny<T> extends true ? true : (string extends keyof T ? true : (number extends keyof T ? (symbol extends keyof T ? true : false) : false));
+type HasRequired<T extends {
+    body?: any;
+    query?: any;
+    params?: any;
+}> = T["body"] extends object ? HasRequiredKeys<T["body"]> extends true ? true : T["query"] extends object ? HasRequiredKeys<T["query"]> extends true ? true : T["params"] extends object ? HasRequiredKeys<T["params"]> : false : T["params"] extends object ? HasRequiredKeys<T["params"]> : false : T["query"] extends object ? HasRequiredKeys<T["query"]> extends true ? true : T["params"] extends object ? HasRequiredKeys<T["params"]> : false : T["params"] extends object ? HasRequiredKeys<T["params"]> : false;
+type InferContext<T> = T extends (ctx: infer Ctx) => any ? Ctx extends object ? Ctx : never : never;
+type WithRequired<T, K extends keyof any> = Prettify<T & {
+    [P in K & keyof T]-?: NonNullable<T[P]>;
+}>;
+type WithoutServerOnly<T extends Record<string, Endpoint>> = {
+    [K in keyof T]: T[K] extends Endpoint<any, infer O> ? O extends {
+        metadata: {
+            SERVER_ONLY: true;
+        };
+    } ? never : T[K] : T[K];
+};
+type MethodOptions<API, M extends HTTPMethod> = API extends {
+    [key: string]: infer T;
+} ? T extends Endpoint<any, infer O> ? O["method"] extends M ? {
+    [key in T["path"]]: T;
+} : O["method"] extends M[] ? M extends O["method"][number] ? {
+    [key in T["path"]]: T;
+} : {} : O["method"] extends "*" ? {
+    [key in T["path"]]: T;
+} : {} : {} : {};
+export type RequiredOptionKeys<C extends {
+    body?: any;
+    query?: any;
+    params?: any;
+}> = (C["body"] extends object ? HasRequiredKeys<C["body"]> extends true ? {
+    body: true;
+} : {} : {}) & (C["query"] extends object ? HasRequiredKeys<C["query"]> extends true ? {
+    query: true;
+} : {} : {}) & (C["params"] extends object ? HasRequiredKeys<C["params"]> extends true ? {
+    params: true;
+} : {} : {});
+type CommonHeaders = {
+    accept: "application/json" | "text/plain" | "application/octet-stream";
+    "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+    authorization: "Bearer" | "Basic";
+};
+type FetchRequestOptions<Body = any, Query extends Record<string, any> = any, Params extends Record<string, any> | Array<string> | undefined = any, Res = any, ExtraOptions extends Record<string, any> = {}> = Prettify<ExtraOptions & Omit<RequestInit, "body"> & {
+    /**
+     * Headers
+     */
+    headers?: CommonHeaders | Headers | HeadersInit;
+    /**
+     * Body
+     */
+    body?: Body;
+    /**
+     * Query parameters (key-value pairs)
+     */
+    query?: Query;
+    /**
+     * Dynamic parameters.
+     *
+     * If url is defined as /path/:id, params will be { id: string }
+     */
+    params?: Params;
+}>;
+type ResponseData<T> = {
+    ok: true;
+    data: T;
+    error: null;
+    response: Response;
+    headers: Headers;
+    status: number;
+    statusText: string;
+};
+type ResponseError<E> = {
+    ok: false;
+    data: null;
+    error: Prettify<(E extends Record<string, any> ? E : {
+        message?: string;
+    }) & {
+        code?: string;
+    }>;
+    response: Response;
+    headers: Headers;
+    status: number;
+    statusText: string;
+};
+type FetchResponse<T, E extends Record<string, unknown> | unknown = unknown, Throw extends boolean = false> = Throw extends true ? T : ResponseData<T> | ResponseError<E>;
+export declare function isJSONSerializable(value: any): boolean;
+export type ResponseType = "json" | "text" | "blob";
+export declare function detectResponseType(request: Response): ResponseType;
+type InferredAPI<R> = R extends {
+    endpoints: Record<string, Endpoint>;
+} ? WithoutServerOnly<R["endpoints"]> : WithoutServerOnly<R & Record<string, Endpoint>>;
+export declare class HTTP<R extends Router | Router["endpoints"]> {
+    authToken: string | undefined;
+    options: FetchRequestOptions;
+    private sdk;
+    constructor(sdk: ColyseusSDK, baseOptions: FetchRequestOptions);
+    private request;
+    get<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "GET">>> = Prettify<UnionToIntersection<MethodOptions<API, "GET">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    get<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "GET">>> = Prettify<UnionToIntersection<MethodOptions<API, "GET">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    post<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "POST">>> = Prettify<UnionToIntersection<MethodOptions<API, "POST">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: (IsAnyOrAnyIndexed<R> extends true ? string : never) | (IsAny<API> extends true ? string : never) | (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : (IsAny<API> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>)): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    post<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "POST">>> = Prettify<UnionToIntersection<MethodOptions<API, "POST">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: (IsAnyOrAnyIndexed<R> extends true ? string : never) | (IsAny<API> extends true ? string : never) | (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : (IsAny<API> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>)): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    delete<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>> = Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    delete<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>> = Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    patch<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>> = Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    patch<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>> = Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    put<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PUT">>> = Prettify<UnionToIntersection<MethodOptions<API, "PUT">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    put<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PUT">>> = Prettify<UnionToIntersection<MethodOptions<API, "PUT">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    protected executeRequest<M extends HTTPMethod>(method: M, path: any, requestOptions?: any): Promise<any>;
+}
+export {};

package/lib/HTTP_bkp.d.ts

@@ -0,0 +1,18 @@
+import * as httpie from "@colyseus/httpie";
+import { ColyseusSDK } from "./Client.ts";
+export declare class HTTP {
+    protected sdk: ColyseusSDK;
+    headers: {
+        [id: string]: string;
+    };
+    authToken: string | undefined;
+    constructor(sdk: ColyseusSDK, headers?: {
+        [id: string]: string;
+    });
+    get<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    post<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    del<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    put<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    protected request(method: "get" | "post" | "put" | "del", path: string, options?: Partial<httpie.Options>): Promise<httpie.Response>;
+    protected getOptions(options: Partial<httpie.Options>): Partial<httpie.Options>;
+}

package/lib/Protocol.d.ts

@@ -0,0 +1,21 @@
+export declare enum Protocol {
+    HANDSHAKE = 9,
+    JOIN_ROOM = 10,
+    ERROR = 11,
+    LEAVE_ROOM = 12,
+    ROOM_DATA = 13,
+    ROOM_STATE = 14,
+    ROOM_STATE_PATCH = 15,
+    ROOM_DATA_SCHEMA = 16,
+    ROOM_DATA_BYTES = 17,
+    PING = 18
+}
+export declare enum ErrorCode {
+    MATCHMAKE_NO_HANDLER = 520,
+    MATCHMAKE_INVALID_CRITERIA = 521,
+    MATCHMAKE_INVALID_ROOM_ID = 522,
+    MATCHMAKE_UNHANDLED = 523,
+    MATCHMAKE_EXPIRED = 524,
+    AUTH_FAILED = 525,
+    APPLICATION_ERROR = 526
+}

package/lib/Room.d.ts

@@ -0,0 +1,140 @@
+import { type Room as ServerRoom, type ExtractMessageType } from '@colyseus/core';
+import { Schema } from '@colyseus/schema';
+import { Packr } from '@colyseus/msgpackr';
+import { Connection } from './Connection.ts';
+import { Serializer } from './serializer/Serializer.ts';
+import { SchemaConstructor, SchemaSerializer } from './serializer/SchemaSerializer.ts';
+export type InferSerializer<State> = [State] extends [Schema] ? SchemaSerializer<State> : Serializer<State>;
+export interface RoomAvailable<Metadata = any> {
+    name: string;
+    roomId: string;
+    clients: number;
+    maxClients: number;
+    metadata?: Metadata;
+}
+export interface ReconnectionOptions {
+    /**
+     * The maximum number of reconnection attempts.
+     */
+    maxRetries: number;
+    /**
+     * The minimum delay between reconnection attempts.
+     */
+    minDelay: number;
+    /**
+     * The maximum delay between reconnection attempts.
+     */
+    maxDelay: number;
+    /**
+     * The minimum uptime of the room before reconnection attempts can be made.
+     */
+    minUptime: number;
+    /**
+     * The current number of reconnection attempts.
+     */
+    retryCount: number;
+    /**
+     * The initial delay between reconnection attempts.
+     */
+    delay: number;
+    /**
+     * The function to calculate the delay between reconnection attempts.
+     * @param attempt - The current attempt number.
+     * @param delay - The initial delay between reconnection attempts.
+     * @returns The delay between reconnection attempts.
+     */
+    backoff: (attempt: number, delay: number) => number;
+    /**
+     * The maximum number of enqueued messages to buffer.
+     */
+    maxEnqueuedMessages: number;
+    /**
+     * Buffer for messages sent while connection is not open.
+     * These messages will be sent once the connection is re-established.
+     */
+    enqueuedMessages: Array<{
+        data: Uint8Array;
+    }>;
+    /**
+     * Whether the room is currently reconnecting.
+     */
+    isReconnecting: boolean;
+}
+export declare class Room<RoomType extends typeof ServerRoom = any, State = RoomType['prototype']['state']> {
+    #private;
+    roomId: string;
+    sessionId: string;
+    reconnectionToken: string;
+    name: string;
+    connection: Connection;
+    onStateChange: {
+        once: (cb: (state: State) => void) => void;
+        remove: (cb: (state: State) => void) => void;
+        invoke: (state: State) => void;
+        invokeAsync: (state: State) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (state: State) => void) => import("./core/signal.ts").EventEmitter<(state: State) => void>);
+    onError: {
+        once: (cb: (code: number, message?: string) => void) => void;
+        remove: (cb: (code: number, message?: string) => void) => void;
+        invoke: (code: number, message?: string) => void;
+        invokeAsync: (code: number, message?: string) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (code: number, message?: string) => void) => import("./core/signal.ts").EventEmitter<(code: number, message?: string) => void>);
+    onLeave: {
+        once: (cb: (code: number, reason?: string) => void) => void;
+        remove: (cb: (code: number, reason?: string) => void) => void;
+        invoke: (code: number, reason?: string) => void;
+        invokeAsync: (code: number, reason?: string) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (code: number, reason?: string) => void) => import("./core/signal.ts").EventEmitter<(code: number, reason?: string) => void>);
+    onReconnect: {
+        once: (cb: () => void) => void;
+        remove: (cb: () => void) => void;
+        invoke: () => void;
+        invokeAsync: () => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: () => void) => import("./core/signal.ts").EventEmitter<() => void>);
+    onDrop: {
+        once: (cb: (code: number, reason?: string) => void) => void;
+        remove: (cb: (code: number, reason?: string) => void) => void;
+        invoke: (code: number, reason?: string) => void;
+        invokeAsync: (code: number, reason?: string) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (code: number, reason?: string) => void) => import("./core/signal.ts").EventEmitter<(code: number, reason?: string) => void>);
+    protected onJoin: {
+        once: (cb: (...args: any[]) => void | Promise<any>) => void;
+        remove: (cb: (...args: any[]) => void | Promise<any>) => void;
+        invoke: (...args: any[]) => void;
+        invokeAsync: (...args: any[]) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (...args: any[]) => void | Promise<any>) => import("./core/signal.ts").EventEmitter<(...args: any[]) => void | Promise<any>>);
+    serializerId: string;
+    serializer: InferSerializer<State>;
+    reconnection: ReconnectionOptions;
+    protected joinedAtTime: number;
+    protected onMessageHandlers: {
+        emit(event: string, ...args: any[]): void;
+        events: {};
+        on(event: string, cb: (...args: any[]) => void): () => void;
+    };
+    protected packr: Packr;
+    constructor(name: string, rootSchema?: SchemaConstructor<State>);
+    connect(endpoint: string, options?: any, headers?: any): void;
+    leave(consented?: boolean): Promise<number>;
+    onMessage<MessageType extends keyof RoomType['prototype']['~client']['~messages']>(message: MessageType, callback: (payload: RoomType['prototype']['~client']['~messages'][MessageType]) => void): any;
+    onMessage<T = any>(type: "*", callback: (messageType: string | number, payload: T) => void): any;
+    onMessage<T = any>(type: string | number, callback: (payload: T) => void): any;
+    ping(callback: (ms: number) => void): void;
+    send<MessageType extends keyof RoomType['prototype']['messages']>(messageType: MessageType, payload?: ExtractMessageType<RoomType['prototype']['messages'][MessageType]>): any;
+    sendUnreliable<T = any>(type: string | number, message?: T): void;
+    sendBytes(type: string | number, bytes: Uint8Array): void;
+    get state(): State;
+    removeAllListeners(): void;
+    protected onMessageCallback(event: MessageEvent): void;
+    private dispatchMessage;
+    private destroy;
+    private getMessageHandlerKey;
+    private handleReconnection;
+    private retryReconnection;
+}

package/lib/Storage.d.ts

@@ -0,0 +1,3 @@
+export declare function setItem(key: string, value: string): void;
+export declare function removeItem(key: string): void;
+export declare function getItem(key: string, callback: Function): void;