@colyseus/core/build/MatchMaker.d.ts

Multiplayer Framework for Node.js.

import { type Type, Deferred, type ExtractMethodOrPropertyType } from './utils/Utils.ts';
import { RegisteredHandler } from './matchmaker/RegisteredHandler.ts';
import { type OnCreateOptions, Room } from './Room.ts';
import { type Presence } from './presence/Presence.ts';
import { type IRoomCache, type MatchMakerDriver, type SortOptions } from './matchmaker/LocalDriver/LocalDriver.ts';
import { controller } from './matchmaker/controller.ts';
import * as stats from './Stats.ts';
import type { AuthContext } from './Transport.ts';
import { type ExtractRoomCacheMetadata } from './matchmaker/driver.ts';
import { type ISeatReservation } from '@colyseus/shared-types';
export type { ISeatReservation, ExtractRoomCacheMetadata };
export { controller, stats, type MatchMakerDriver };
export type ClientOptions = any;
export type SelectProcessIdCallback = (roomName: string, clientOptions: ClientOptions) => Promise<string>;
export declare let publicAddress: string;
export declare let processId: string;
export declare let presence: Presence;
export declare let driver: MatchMakerDriver;
/**
 * Function to select the processId to create the room on.
 * By default, returns the process with least amount of rooms created.
 * @returns The processId to create the room on.
 */
export declare let selectProcessIdToCreateRoom: SelectProcessIdCallback;
export declare function setHealthChecksEnabled(value: boolean): void;
export declare let onReady: Deferred;
export declare const MatchMakerState: {
    readonly INITIALIZING: 0;
    readonly READY: 1;
    readonly SHUTTING_DOWN: 2;
};
export type MatchMakerState = (typeof MatchMakerState)[keyof typeof MatchMakerState];
/**
 * Internal MatchMaker state
 */
export declare let state: MatchMakerState;
/**
 * @private
 */
export declare function setup(_presence?: Presence, _driver?: MatchMakerDriver, _publicAddress?: string, _selectProcessIdToCreateRoom?: SelectProcessIdCallback): Promise<void>;
/**
 * - Accept receiving remote room creation requests
 * - Check for leftover/invalid processId's on startup
 * @private
 */
export declare function accept(isStandalone?: boolean): Promise<void>;
/**
 * Join or create into a room and return seat reservation
 */
export declare function joinOrCreate(roomName: string, clientOptions?: ClientOptions, authContext?: AuthContext): Promise<ISeatReservation>;
/**
 * Create a room and return seat reservation
 */
export declare function create(roomName: string, clientOptions?: ClientOptions, authContext?: AuthContext): Promise<ISeatReservation>;
/**
 * Join a room and return seat reservation
 */
export declare function join(roomName: string, clientOptions?: ClientOptions, authContext?: AuthContext): Promise<ISeatReservation>;
/**
 * Join a room by id and return seat reservation
 */
export declare function reconnect(roomId: string, clientOptions?: ClientOptions): Promise<ISeatReservation>;
/**
 * Join a room by id and return client seat reservation. An exception is thrown if a room is not found for roomId.
 *
 * @param roomId - The Id of the specific room instance.
 * @param clientOptions - Options for the client seat reservation (for `onJoin`/`onAuth`)
 * @param authContext - Optional authentication token
 *
 * @returns Promise<SeatReservation> - A promise which contains `sessionId` and `IRoomCache`.
 */
export declare function joinById(roomId: string, clientOptions?: ClientOptions, authContext?: AuthContext): Promise<ISeatReservation>;
/**
 * Perform a query for all cached rooms
 */
export declare function query<T extends Room = any>(conditions?: Partial<IRoomCache & ExtractRoomCacheMetadata<T>>, sortOptions?: SortOptions): Promise<IRoomCache<ExtractRoomCacheMetadata<T>>[]>;
/**
 * Find for a public and unlocked room available.
 *
 * @param roomName - The Id of the specific room.
 * @param filterOptions - Filter options.
 * @param sortOptions - Sorting options.
 *
 * @returns Promise<IRoomCache> - A promise contaning an object which includes room metadata and configurations.
 */
export declare function findOneRoomAvailable(roomName: string, filterOptions: ClientOptions, additionalSortOptions?: SortOptions): Promise<IRoomCache<any>>;
/**
 * Call a method or return a property on a remote room.
 *
 * @param roomId - The Id of the specific room instance.
 * @param method - Method or attribute to call or retrive.
 * @param args - Array of arguments for the method
 *
 * @returns Promise<any> - Returned value from the called or retrieved method/attribute.
 */
export declare function remoteRoomCall<TRoom = Room>(roomId: string, method: keyof TRoom, args?: any[], rejectionTimeout?: number): Promise<ExtractMethodOrPropertyType<TRoom, typeof method>>;
export declare function defineRoomType<T extends Type<Room>>(roomName: string, klass: T, defaultOptions?: OnCreateOptions<T>): RegisteredHandler<InstanceType<T>>;
export declare function addRoomType(handler: RegisteredHandler): void;
export declare function removeRoomType(roomName: string): void;
export declare function getAllHandlers(): {
    [id: string]: RegisteredHandler<any>;
};
export declare function getHandler(roomName: string): RegisteredHandler<any>;
export declare function getRoomClass(roomName: string): Type<Room>;
/**
 * Creates a new room.
 *
 * @param roomName - The identifier you defined on `gameServer.define()`
 * @param clientOptions - Options for `onCreate`
 *
 * @returns Promise<IRoomCache> - A promise contaning an object which includes room metadata and configurations.
 */
export declare function createRoom(roomName: string, clientOptions: ClientOptions): Promise<IRoomCache>;
export declare function handleCreateRoom(roomName: string, clientOptions: ClientOptions, restoringRoomId?: string): Promise<IRoomCache>;
/**
 * Get room data by roomId.
 * This method does not return the actual room instance, use `getLocalRoomById` for that.
 */
export declare function getRoomById(roomId: string): Promise<IRoomCache<any>>;
/**
 * Get local room instance by roomId. (Can return "undefined" if the room is not available on this process)
 */
export declare function getLocalRoomById(roomId: string): Room<import("./Room.ts").RoomOptions>;
/**
 * Disconnects every client on every room in the current process.
 */
export declare function disconnectAll(closeCode?: number): Promise<any>[];
export declare function gracefullyShutdown(): Promise<any>;
/**
 * DO NOT USE THIS IN PRODUCTION.
 * THIS METHOD IS MEANT TO BE USED FOR VITE DEV SERVER ONLY.
 * ---------------------------------------------------------
 *
 *
 * Lightweight HMR reload for dev mode.
 *
 * Unlike gracefullyShutdown() + setup() + accept(), this preserves the
 * matchMaker infrastructure (presence, driver, IPC subscriptions, processId)
 * and only cycles room instances: cache state → dispose → restore.
 */
export declare function hotReload(): Promise<void>;
/**
 * Reserve a seat for a client in a room
 */
export declare function reserveSeatFor(room: IRoomCache, options: ClientOptions, authData?: any): Promise<ISeatReservation>;
/**
 * Reserve multiple seats for clients in a room
 */
export declare function reserveMultipleSeatsFor(room: IRoomCache, clientsData: Array<{
    sessionId: string;
    options: ClientOptions;
    auth: any;
}>): Promise<boolean[]>;
/**
 * Build a seat reservation object.
 * @param room - The room to build a seat reservation for.
 * @param sessionId - The session ID of the client.
 * @returns A seat reservation object.
 */
export declare function buildSeatReservation(room: IRoomCache, sessionId: string): ISeatReservation;
/**
 * Perform health check on all processes
 */
export declare function healthCheckAllProcesses(): Promise<void>;
export declare function healthCheckProcessId(processId: string): Promise<any>;