@colyseus/core 0.16.23 → 0.17.0

package/build/{Transport.d.ts → src/Transport.d.ts}

@@ -1,31 +1,51 @@
 import * as http from 'http';
 import * as https from 'https';
-import * as net from 'net';
-import { Schema, StateView } from '@colyseus/schema';
+import { StateView } from '@colyseus/schema';
 import { EventEmitter } from 'events';
+import type { Room } from './Room.ts';
 export declare abstract class Transport {
     protocol?: string;
-    server?: net.Server | http.Server | https.Server;
+    server?: http.Server | https.Server;
     abstract listen(port?: number, hostname?: string, backlog?: number, listeningListener?: Function): this;
     abstract shutdown(): void;
     abstract simulateLatency(milliseconds: number): void;
 }
 export type AuthContext = {
     token?: string;
-    headers: http.IncomingHttpHeaders;
+    headers: Headers;
     ip: string | string[];
-    req?: http.IncomingMessage;
+    req?: any;
 };
 export interface ISendOptions {
     afterNextPatch?: boolean;
 }
-export declare enum ClientState {
-    JOINING = 0,
-    JOINED = 1,
-    RECONNECTED = 2,
-    LEAVING = 3,
-    CLOSED = 4
-}
+export declare const ClientState: {
+    readonly JOINING: 0;
+    readonly JOINED: 1;
+    readonly RECONNECTED: 2;
+    readonly LEAVING: 3;
+    readonly CLOSED: 4;
+};
+export type ClientState = (typeof ClientState)[keyof typeof ClientState];
+type ExtractClientUserData<T> = T extends {
+    userData: infer U;
+} ? U : T;
+type ExtractClientAuth<T> = T extends {
+    auth: infer A;
+} ? A : any;
+type ExtractClientMessages<T> = T extends {
+    messages: infer M;
+} ? M : any;
+export type MessageArgs<M, Options> = unknown extends M ? [message?: M, options?: Options] : [
+    M
+] extends [never] ? [message?: M, options?: Options] : [
+    M
+] extends [void] ? [message?: M, options?: Options] : [
+    M
+] extends [undefined] ? [message?: M, options?: Options] : undefined extends M ? [message?: M, options?: Options] : [
+    message: M,
+    options?: Options
+];
 /**
  * The client instance from the server-side is responsible for the transport layer between the server and the client.
  * It should not be confused with the Client from the client-side SDK, as they have completely different purposes!
@@ -34,7 +54,12 @@ export declare enum ClientState {
  * - This is the raw WebSocket connection coming from the `ws` package. There are more methods available which aren't
  *  encouraged to use along with Colyseus.
  */
-export interface Client<UserData = any, AuthData = any> {
+export interface Client<T extends {
+    userData?: any;
+    auth?: any;
+    messages?: Record<string | number, any>;
+} = any> {
+    '~messages': ExtractClientMessages<T>;
     ref: EventEmitter;
     /**
      * @deprecated use `sessionId` instead.
@@ -57,11 +82,11 @@ export interface Client<UserData = any, AuthData = any> {
      * - Can be used to store custom data about the client's connection. userData is not synchronized with the client,
      * and should be used only to keep player-specific with its connection.
      */
-    userData?: UserData;
+    userData?: ExtractClientUserData<T>;
     /**
      * auth data provided by your `onAuth`
      */
-    auth?: AuthData;
+    auth?: ExtractClientAuth<T>;
     /**
      * Reconnection token used to re-join the room after onLeave + allowReconnection().
      *
@@ -80,8 +105,7 @@ export interface Client<UserData = any, AuthData = any> {
      * @param message Message payload. (automatically encoded with msgpack.)
      * @param options
      */
-    send(type: string | number, message?: any, options?: ISendOptions): void;
-    send(message: Schema, options?: ISendOptions): void;
+    send<K extends keyof this['~messages']>(type: K, ...args: MessageArgs<this['~messages'][K], ISendOptions>): void;
     /**
      * Send raw bytes to this specific client.
      *
@@ -95,7 +119,7 @@ export interface Client<UserData = any, AuthData = any> {
      *
      * @param code Custom close code. Default value is 1000.
      * @param data
-     * @see {@link https://docs.colyseus.io/colyseus/server/room/#leavecode-number}
+     * @see [Leave room](https://docs.colyseus.io/room#leave-room)
      */
     leave(code?: number, data?: string): void;
     /**
@@ -120,10 +144,29 @@ export interface Client<UserData = any, AuthData = any> {
 export interface ClientPrivate {
     readyState: number;
     _enqueuedMessages?: any[];
-    _afterNextPatchQueue: Array<[string | Client, IArguments]>;
+    _afterNextPatchQueue: Array<[string | number | Client, ArrayLike<any>]>;
     _joinedAt: number;
+    /**
+     * Used for rate limiting via maxMessagesPerSecond.
+     */
+    _numMessagesLastSecond?: number;
+    _lastMessageTime?: number;
 }
-export declare class ClientArray<UserData = any, AuthData = any> extends Array<Client<UserData, AuthData>> {
-    getById(sessionId: string): Client<UserData, AuthData> | undefined;
-    delete(client: Client<UserData, AuthData>): boolean;
+export declare class ClientArray<C extends Client = Client> extends Array<C> {
+    getById(sessionId: string): C | undefined;
+    delete(client: C): boolean;
 }
+/**
+ * Shared internal method to connect a Client into a Room.
+ * Validates seat reservation and joins the client to the room.
+ *
+ * @remarks
+ * **⚠️ This is an internal API and not intended for end-user use.**
+ *
+ * @internal
+ */
+export declare function connectClientToRoom(room: Room | undefined, client: Client & ClientPrivate, authContext: AuthContext, connectionOptions: {
+    reconnectionToken?: string;
+    skipHandshake?: boolean;
+}): Promise<void>;
+export {};

package/build/{errors → src/errors}/RoomExceptions.d.ts

@@ -1,5 +1,5 @@
-import type { Client } from '../Transport.js';
-import type { ExtractAuthData, ExtractUserData, Room } from '../Room.js';
+import type { ExtractMessageType, Room } from '../Room.ts';
+export type RoomMethodName = 'onCreate' | 'onAuth' | 'onJoin' | 'onLeave' | 'onDispose' | 'onMessage' | 'setSimulationInterval' | 'setInterval' | 'setTimeout';
 export type RoomException<R extends Room = Room> = OnCreateException<R> | OnAuthException<R> | OnJoinException<R> | OnLeaveException<R> | OnDisposeException | OnMessageException<R> | SimulationIntervalException | TimedEventException;
 export declare class OnCreateException<R extends Room = Room> extends Error {
     options: Parameters<R['onCreate']>[0];
@@ -24,11 +24,12 @@ export declare class OnLeaveException<R extends Room = Room> extends Error {
 export declare class OnDisposeException extends Error {
     constructor(cause: Error, message: string);
 }
-export declare class OnMessageException<R extends Room = Room, MessagePayload = any> extends Error {
-    client: Client<ExtractUserData<R['clients']>, ExtractAuthData<R['clients']>>;
-    payload: MessagePayload;
-    type: string;
-    constructor(cause: Error, message: string, client: Client<ExtractUserData<R['clients']>, ExtractAuthData<R['clients']>>, payload: MessagePayload, type: string);
+export declare class OnMessageException<R extends Room, MessageType extends keyof R['messages'] = keyof R['messages']> extends Error {
+    client: R['~client'];
+    payload: ExtractMessageType<R['messages'][MessageType]>;
+    type: MessageType;
+    constructor(cause: Error, message: string, client: R['~client'], payload: ExtractMessageType<R['messages'][MessageType]>, type: MessageType);
+    isType<T extends keyof R['messages']>(type: T): this is OnMessageException<R, T>;
 }
 export declare class SimulationIntervalException extends Error {
     constructor(cause: Error, message: string);

package/build/src/index.d.ts

@@ -0,0 +1,27 @@
+import { ClockTimer as Clock, Delayed } from '@colyseus/timer';
+export { Server, defineRoom, defineServer, type ServerOptions, type SDKTypes } from './Server.ts';
+export { Room, room, RoomInternalState, validate, type RoomOptions, type MessageHandlerWithFormat, type ExtractMessageType, type Messages, type ExtractRoomState, type ExtractRoomMetadata, type ExtractRoomClient } from './Room.ts';
+export { Protocol, ErrorCode, getMessageBytes, CloseCode } from './Protocol.ts';
+export { RegisteredHandler } from './matchmaker/RegisteredHandler.ts';
+export { ServerError } from './errors/ServerError.ts';
+export { type RoomException, type RoomMethodName, OnCreateException, OnAuthException, OnJoinException, OnLeaveException, OnDisposeException, OnMessageException, SimulationIntervalException, TimedEventException, } from './errors/RoomExceptions.ts';
+import * as matchMaker from './MatchMaker.ts';
+export { matchMaker };
+export { updateLobby, subscribeLobby } from './matchmaker/Lobby.ts';
+export * from './matchmaker/LocalDriver/LocalDriver.ts';
+export { initializeRoomCache } from './matchmaker/driver.ts';
+export { type Client, type ClientPrivate, type AuthContext, ClientState, ClientArray, Transport, type ISendOptions, connectClientToRoom } from './Transport.ts';
+export { type Presence } from './presence/Presence.ts';
+export { LocalPresence } from './presence/LocalPresence.ts';
+export { type Serializer } from './serializer/Serializer.ts';
+export { SchemaSerializer } from './serializer/SchemaSerializer.ts';
+export { Clock, Delayed };
+export { generateId, Deferred, HttpServerMock, spliceOne, getBearerToken } from './utils/Utils.ts';
+export { isDevMode } from './utils/DevMode.ts';
+export { subscribeIPC, requestFromIPC } from './IPC.ts';
+export { debugMatchMaking, debugMessage, debugPatch, debugError, debugConnection, debugDriver, debugPresence, debugAndPrintError, } from './Debug.ts';
+export { LobbyRoom } from './rooms/LobbyRoom.ts';
+export { RelayRoom } from './rooms/RelayRoom.ts';
+export { RankedQueueRoom, type RankedQueueOptions, type MatchGroup, type MatchTeam, type ClientQueueData } from './rooms/RankedQueueRoom.ts';
+export { createEndpoint, createInternalContext, createMiddleware, createRouter, toNodeHandler, __globalEndpoints, type Router, } from './router/index.ts';
+export { logger } from './Logger.ts';

package/build/src/matchmaker/Lobby.d.ts

@@ -0,0 +1,4 @@
+import type { Room } from '../Room.ts';
+import type { IRoomCache } from './driver.ts';
+export declare function updateLobby<T extends Room>(room: T, removed?: boolean): void;
+export declare function subscribeLobby(callback: (roomId: string, roomListing: IRoomCache) => void): Promise<() => any>;

package/build/src/matchmaker/LocalDriver/LocalDriver.d.ts

@@ -0,0 +1,17 @@
+import type { IRoomCache, SortOptions, MatchMakerDriver } from '../driver.ts';
+export type { IRoomCache, SortOptions, MatchMakerDriver };
+export declare class LocalDriver implements MatchMakerDriver {
+    rooms: IRoomCache[];
+    has(roomId: string): boolean;
+    query(conditions: Partial<IRoomCache>, sortOptions?: SortOptions): IRoomCache<any>[];
+    cleanup(processId: string): Promise<void>;
+    findOne(conditions: Partial<IRoomCache>, sortOptions?: SortOptions): Promise<IRoomCache>;
+    update(room: IRoomCache, operations: Partial<{
+        $set: Partial<IRoomCache>;
+        $inc: Partial<IRoomCache>;
+    }>): boolean;
+    persist(room: IRoomCache, create?: boolean): boolean;
+    remove(roomId: string): boolean;
+    clear(): void;
+    shutdown(): void;
+}

package/build/src/matchmaker/LocalDriver/Query.d.ts

@@ -0,0 +1,12 @@
+import type { IRoomCache, SortOptions } from '../driver.ts';
+export declare class Query<T extends IRoomCache> {
+    private $rooms;
+    private conditions;
+    private sortOptions?;
+    constructor(rooms: any[], conditions: any);
+    sort(options: SortOptions): this;
+    private applySort;
+    private applyFilter;
+    filter(conditions: any): T[];
+    then(resolve: any, reject: any): any;
+}

package/build/src/matchmaker/RegisteredHandler.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'events';
+import { Room } from './../Room.ts';
+import type { IRoomCache, SortOptions, IRoomCacheFilterByKeys, IRoomCacheSortByKeys, ExtractMetadata } from './driver.ts';
+import type { Client } from '../Transport.ts';
+import type { Type } from "../utils/Utils.ts";
+export declare const INVALID_OPTION_KEYS: Array<keyof IRoomCache>;
+/**
+ * Type for filterBy that supports both onCreate options and metadata fields
+ */
+type FilterByKeys<RoomType extends Room> = IRoomCacheFilterByKeys | (ExtractMetadata<RoomType> extends object ? keyof ExtractMetadata<RoomType> & string : never);
+/**
+ * Type for sortBy that supports room cache fields and metadata fields
+ */
+type SortByKeys<RoomType extends Room> = IRoomCacheSortByKeys | (ExtractMetadata<RoomType> extends object ? keyof ExtractMetadata<RoomType> & string : never);
+export interface RegisteredHandlerEvents<RoomType extends Type<Room> = any> {
+    create: [room: InstanceType<RoomType>];
+    lock: [room: InstanceType<RoomType>];
+    unlock: [room: InstanceType<RoomType>];
+    join: [room: InstanceType<RoomType>, client: Client];
+    leave: [room: InstanceType<RoomType>, client: Client, willDispose: boolean];
+    dispose: [room: InstanceType<RoomType>];
+    'visibility-change': [room: InstanceType<RoomType>, isVisible: boolean];
+    'metadata-change': [room: InstanceType<RoomType>];
+}
+export declare class RegisteredHandler<RoomType extends Type<Room> = any> extends EventEmitter<RegisteredHandlerEvents<RoomType>> {
+    '~room': RoomType;
+    klass: RoomType;
+    options: any;
+    name: string;
+    filterOptions: Array<FilterByKeys<InstanceType<RoomType>>>;
+    sortOptions?: SortOptions;
+    realtimeListingEnabled: boolean;
+    constructor(klass: RoomType, options?: any);
+    enableRealtimeListing(): this;
+    /**
+     * Define which fields should be used for filtering rooms.
+     * Supports both onCreate options and metadata fields using dot notation.
+     *
+     * @example
+     * // Filter by IRoomCache fields
+     * .filterBy(['maxClients'])
+     *
+     * @example
+     * // Filter by metadata fields
+     * .filterBy(['difficulty', 'metadata.region'])
+     *
+     * @example
+     * // Mix both
+     * .filterBy(['mode', 'difficulty', 'maxClients'])
+     */
+    filterBy<T extends FilterByKeys<InstanceType<RoomType>>>(options: T[]): this;
+    /**
+     * Define how rooms should be sorted when querying.
+     * Supports both room cache fields and metadata fields using dot notation.
+     *
+     * @example
+     * // Sort by number of clients (descending)
+     * .sortBy({ clients: -1 })
+     *
+     * @example
+     * // Sort by metadata field
+     * .sortBy({ 'metadata.rating': -1 })
+     *
+     * @example
+     * // Multiple sort criteria
+     * .sortBy({ 'metadata.skillLevel': 1, clients: -1 })
+     */
+    sortBy<T extends SortByKeys<InstanceType<RoomType>>>(options: {
+        [K in T]: SortOptions[string];
+    }): this;
+    getMetadataFromOptions(options: any): {
+        metadata: {};
+    } | {
+        metadata?: undefined;
+    };
+    /**
+     * Extract filter options from client options.
+     */
+    getFilterOptions(options: any): {};
+}
+export {};

package/build/{matchmaker → src/matchmaker}/controller.d.ts

@@ -2,9 +2,8 @@
  * Matchmaking controller
  * (for interoperability between different http frameworks, e.g. express, uWebSockets.js, etc)
  */
-import { IncomingMessage } from 'http';
-import * as matchMaker from '../MatchMaker.js';
-import type { AuthContext } from '../Transport.js';
+import * as matchMaker from '../MatchMaker.ts';
+import type { AuthContext } from '../Transport.ts';
 declare const _default: {
     DEFAULT_CORS_HEADERS: {
         'Access-Control-Allow-Headers': string;
@@ -20,8 +19,8 @@ declare const _default: {
      * You can manually change the default corsHeaders by overwriting the `getCorsHeaders()` method:
      *    ```
      *    import { matchMaker } from "@colyseus/core";
-     *    matchMaker.controller.getCorsHeaders = function(req) {
-     *      if (req.headers.referer !== "xxx") {
+     *    matchMaker.controller.getCorsHeaders = function(headers) {
+     *      if (headers.get('referer') !== "xxx") {
      *      }
      *
      *      return {
@@ -30,7 +29,7 @@ declare const _default: {
      *    }
      *    ```
      */
-    getCorsHeaders(req: IncomingMessage): {
+    getCorsHeaders(headers: Headers): {
         [header: string]: string;
     };
     invokeMethod(method: string, roomName: string, clientOptions?: matchMaker.ClientOptions, authOptions?: AuthContext): Promise<any>;

package/build/src/matchmaker/driver/api.d.ts

@@ -0,0 +1,145 @@
+import type { Room } from "@colyseus/core";
+/**
+ * Sort options for room queries.
+ */
+export interface SortOptions {
+    [fieldName: string]: 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+}
+/**
+ * Built-in room cache fields that can be used for sorting.
+ */
+export type IRoomCacheSortByKeys = 'clients' | 'maxClients' | 'createdAt';
+/**
+ * Built-in room cache fields that can be used for filtering.
+ */
+export type IRoomCacheFilterByKeys = 'clients' | 'maxClients' | 'processId';
+/**
+ * Extract metadata type from Room type
+ */
+export type ExtractMetadata<RoomType extends Room> = RoomType extends Room<infer M> ? M : any;
+/**
+ * Generates a unique lock ID based on filter options.
+ */
+export declare function getLockId(filterOptions: any): string;
+/**
+ * Initialize a room cache which contains CRUD operations for room listings.
+ *
+ * @internal
+ * @param initialValues - Predefined room properties.
+ * @returns RoomData - New room cache.
+ */
+export declare function initializeRoomCache(initialValues?: Partial<IRoomCache>): IRoomCache;
+export interface IRoomCache<Metadata = any> {
+    /**
+     * Room name.
+     */
+    name: string;
+    /**
+     * Unique identifier for the room.
+     */
+    roomId: string;
+    /**
+     * Process id where the room is running.
+     */
+    processId: string;
+    /**
+     * Number of clients connected to this room.
+     */
+    clients: number;
+    /**
+     * Maximum number of clients allowed to join the room.
+     */
+    maxClients: number;
+    /**
+     * Indicates if the room is locked (i.e. join requests are rejected).
+     */
+    locked?: boolean;
+    /**
+     * Indicates if the room is private
+     * Private rooms can't be joined via `join()` or `joinOrCreate()`.
+     */
+    private?: boolean;
+    /**
+     * Public address of the server.
+     */
+    publicAddress?: string;
+    /**
+     * Do not show this room in lobby listing.
+     */
+    unlisted?: boolean;
+    /**
+     * Metadata associated with the room.
+     */
+    metadata?: Metadata;
+    /**
+     * When the room was created.
+     */
+    createdAt?: Date;
+}
+export interface MatchMakerDriver {
+    /**
+     * Check if a room exists in room cache.
+     *
+     * @param roomId - The room id.
+     *
+     * @returns Promise<boolean> | boolean - A promise or a boolean value indicating if the room exists.
+     */
+    has(roomId: string): Promise<boolean> | boolean;
+    /**
+     * Query rooms in room cache for given conditions.
+     *
+     * @param conditions - Filtering conditions.
+     *
+     * @returns Promise<IRoomCache[]> | IRoomCache[] - A promise or an object contaning room metadata list.
+     */
+    query<T extends Room = any>(conditions: Partial<IRoomCache & ExtractMetadata<T>>, sortOptions?: SortOptions): Promise<Array<IRoomCache<ExtractMetadata<T>>>> | Array<IRoomCache<ExtractMetadata<T>>>;
+    /**
+     * Clean up rooms in room cache by process id.
+     * @param processId - The process id.
+     */
+    cleanup?(processId: string): Promise<void>;
+    /**
+     * Query for a room in room cache for given conditions.
+     *
+     * @param conditions - Filtering conditions.
+     *
+     * @returns `IRoomCache` - An object contaning filtered room metadata.
+     */
+    findOne<T extends Room = any>(conditions: Partial<IRoomCache & ExtractMetadata<T>>, sortOptions?: SortOptions): Promise<IRoomCache<ExtractMetadata<T>>>;
+    /**
+     * Remove a room from room cache.
+     *
+     * @param roomId - The room id.
+     */
+    remove(roomId: string): Promise<boolean> | boolean;
+    /**
+     * Update a room in room cache.
+     *
+     * @param IRoomCache - The room to update.
+     * @param operations - The operations to update the room.
+     */
+    update(room: IRoomCache, operations: Partial<{
+        $set: Partial<IRoomCache>;
+        $inc: Partial<IRoomCache>;
+    }>): Promise<boolean> | boolean;
+    /**
+     * Persist a room in room cache.
+     *
+     * @param room - The room to persist.
+     * @param create - If true, create a new record. If false (default), update existing record.
+     */
+    persist(room: IRoomCache, create?: boolean): Promise<boolean> | boolean;
+    /**
+     * Empty the room cache. Used for testing purposes only.
+     * @internal Do not call this method yourself.
+     */
+    clear(): void;
+    /**
+     * Boot the room cache medium (if available).
+     */
+    boot?(): Promise<void>;
+    /**
+     * Dispose the connection of the room cache medium.
+     */
+    shutdown(): void;
+}

package/build/src/matchmaker/driver/local/LocalDriver.d.ts

@@ -0,0 +1,17 @@
+import type { IRoomCache, SortOptions, MatchMakerDriver } from '../api.ts';
+export type { IRoomCache, SortOptions, MatchMakerDriver };
+export declare class LocalDriver implements MatchMakerDriver {
+    rooms: IRoomCache[];
+    has(roomId: string): boolean;
+    query(conditions: Partial<IRoomCache>, sortOptions?: SortOptions): IRoomCache<any>[];
+    cleanup(processId: string): Promise<void>;
+    findOne(conditions: Partial<IRoomCache>, sortOptions?: SortOptions): Promise<IRoomCache>;
+    update(room: IRoomCache, operations: Partial<{
+        $set: Partial<IRoomCache>;
+        $inc: Partial<IRoomCache>;
+    }>): boolean;
+    persist(room: IRoomCache, create?: boolean): boolean;
+    remove(roomId: string): boolean;
+    clear(): void;
+    shutdown(): void;
+}

package/build/src/matchmaker/driver/local/Query.d.ts

@@ -0,0 +1,12 @@
+import type { IRoomCache, SortOptions } from '../api.ts';
+export declare class Query<T extends IRoomCache> {
+    private $rooms;
+    private conditions;
+    private sortOptions?;
+    constructor(rooms: any[], conditions: any);
+    sort(options: SortOptions): this;
+    private applySort;
+    private applyFilter;
+    filter(conditions: any): T[];
+    then(resolve: any, reject: any): any;
+}

package/build/src/matchmaker/driver.d.ts

@@ -0,0 +1,145 @@
+import type { Room } from "@colyseus/core";
+/**
+ * Sort options for room queries.
+ */
+export interface SortOptions {
+    [fieldName: string]: 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
+}
+/**
+ * Built-in room cache fields that can be used for sorting.
+ */
+export type IRoomCacheSortByKeys = 'clients' | 'maxClients' | 'createdAt';
+/**
+ * Built-in room cache fields that can be used for filtering.
+ */
+export type IRoomCacheFilterByKeys = 'clients' | 'maxClients' | 'processId';
+/**
+ * Extract metadata type from Room type
+ */
+export type ExtractMetadata<RoomType extends Room> = RoomType['~metadata'];
+/**
+ * Generates a unique lock ID based on filter options.
+ */
+export declare function getLockId(filterOptions: any): string;
+/**
+ * Initialize a room cache which contains CRUD operations for room listings.
+ *
+ * @internal
+ * @param initialValues - Predefined room properties.
+ * @returns RoomData - New room cache.
+ */
+export declare function initializeRoomCache(initialValues?: Partial<IRoomCache>): IRoomCache;
+export interface IRoomCache<Metadata = any> {
+    /**
+     * Room name.
+     */
+    name: string;
+    /**
+     * Unique identifier for the room.
+     */
+    roomId: string;
+    /**
+     * Process id where the room is running.
+     */
+    processId: string;
+    /**
+     * Number of clients connected to this room.
+     */
+    clients: number;
+    /**
+     * Maximum number of clients allowed to join the room.
+     */
+    maxClients: number;
+    /**
+     * Indicates if the room is locked (i.e. join requests are rejected).
+     */
+    locked?: boolean;
+    /**
+     * Indicates if the room is private
+     * Private rooms can't be joined via `join()` or `joinOrCreate()`.
+     */
+    private?: boolean;
+    /**
+     * Public address of the server.
+     */
+    publicAddress?: string;
+    /**
+     * Do not show this room in lobby listing.
+     */
+    unlisted?: boolean;
+    /**
+     * Metadata associated with the room.
+     */
+    metadata?: Metadata;
+    /**
+     * When the room was created.
+     */
+    createdAt?: Date;
+}
+export interface MatchMakerDriver {
+    /**
+     * Check if a room exists in room cache.
+     *
+     * @param roomId - The room id.
+     *
+     * @returns Promise<boolean> | boolean - A promise or a boolean value indicating if the room exists.
+     */
+    has(roomId: string): Promise<boolean> | boolean;
+    /**
+     * Query rooms in room cache for given conditions.
+     *
+     * @param conditions - Filtering conditions.
+     *
+     * @returns Promise<IRoomCache[]> | IRoomCache[] - A promise or an object contaning room metadata list.
+     */
+    query<T extends Room = any>(conditions: Partial<IRoomCache & ExtractMetadata<T>>, sortOptions?: SortOptions): Promise<Array<IRoomCache<ExtractMetadata<T>>>> | Array<IRoomCache<ExtractMetadata<T>>>;
+    /**
+     * Clean up rooms in room cache by process id.
+     * @param processId - The process id.
+     */
+    cleanup?(processId: string): Promise<void>;
+    /**
+     * Query for a room in room cache for given conditions.
+     *
+     * @param conditions - Filtering conditions.
+     *
+     * @returns `IRoomCache` - An object contaning filtered room metadata.
+     */
+    findOne<T extends Room = any>(conditions: Partial<IRoomCache & ExtractMetadata<T>>, sortOptions?: SortOptions): Promise<IRoomCache<ExtractMetadata<T>>>;
+    /**
+     * Remove a room from room cache.
+     *
+     * @param roomId - The room id.
+     */
+    remove(roomId: string): Promise<boolean> | boolean;
+    /**
+     * Update a room in room cache.
+     *
+     * @param IRoomCache - The room to update.
+     * @param operations - The operations to update the room.
+     */
+    update(room: IRoomCache, operations: Partial<{
+        $set: Partial<IRoomCache>;
+        $inc: Partial<IRoomCache>;
+    }>): Promise<boolean> | boolean;
+    /**
+     * Persist a room in room cache.
+     *
+     * @param room - The room to persist.
+     * @param create - If true, create a new record. If false (default), update existing record.
+     */
+    persist(room: IRoomCache, create?: boolean): Promise<boolean> | boolean;
+    /**
+     * Empty the room cache. Used for testing purposes only.
+     * @internal Do not call this method yourself.
+     */
+    clear(): void;
+    /**
+     * Boot the room cache medium (if available).
+     */
+    boot?(): Promise<void>;
+    /**
+     * Dispose the connection of the room cache medium.
+     */
+    shutdown(): void;
+}