@colyseus/sdk 0.17.32 → 0.17.34

package/dist/colyseus.d.ts

@@ -0,0 +1,4148 @@
+// Generated by dts-bundle-generator v9.5.1
+
+interface StandardTypedV1<Input = unknown, Output = Input> {
+	/** The Standard properties. */
+	readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+	/** The Standard Typed properties interface. */
+	interface Props<Input = unknown, Output = Input> {
+		/** The version number of the standard. */
+		readonly version: 1;
+		/** The vendor name of the schema library. */
+		readonly vendor: string;
+		/** Inferred types associated with the schema. */
+		readonly types?: Types<Input, Output> | undefined;
+	}
+	/** The Standard Typed types interface. */
+	interface Types<Input = unknown, Output = Input> {
+		/** The input type of the schema. */
+		readonly input: Input;
+		/** The output type of the schema. */
+		readonly output: Output;
+	}
+	/** Infers the input type of a Standard Typed. */
+	type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+	/** Infers the output type of a Standard Typed. */
+	type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+	/** The Standard Schema properties. */
+	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+	/** The Standard Schema properties interface. */
+	interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+		/** Validates unknown input values. */
+		readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+	}
+	/** The result interface of the validate function. */
+	type Result<Output> = SuccessResult<Output> | FailureResult;
+	/** The result interface if validation succeeds. */
+	interface SuccessResult<Output> {
+		/** The typed output value. */
+		readonly value: Output;
+		/** A falsy value for `issues` indicates success. */
+		readonly issues?: undefined;
+	}
+	interface Options {
+		/** Explicit support for additional vendor-specific parameters, if needed. */
+		readonly libraryOptions?: Record<string, unknown> | undefined;
+	}
+	/** The result interface if validation fails. */
+	interface FailureResult {
+		/** The issues of failed validation. */
+		readonly issues: ReadonlyArray<Issue>;
+	}
+	/** The issue interface of the failure output. */
+	interface Issue {
+		/** The error message of the issue. */
+		readonly message: string;
+		/** The path of the issue, if any. */
+		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+	}
+	/** The path segment interface of the issue. */
+	interface PathSegment {
+		/** The key representing a path segment. */
+		readonly key: PropertyKey;
+	}
+	/** The Standard types interface. */
+	interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+	}
+	/** Infers the input type of a Standard. */
+	type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+	/** Infers the output type of a Standard. */
+	type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/**
+ * Colyseus protocol codes range between 0~100
+ * Use codes between 0~127 for lesser throughput (1 byte)
+ */
+export declare const Protocol: {
+	readonly JOIN_ROOM: 10;
+	readonly ERROR: 11;
+	readonly LEAVE_ROOM: 12;
+	readonly ROOM_DATA: 13;
+	readonly ROOM_STATE: 14;
+	readonly ROOM_STATE_PATCH: 15;
+	readonly ROOM_DATA_SCHEMA: 16;
+	readonly ROOM_DATA_BYTES: 17;
+	readonly PING: 18;
+};
+export type Protocol = typeof Protocol[keyof typeof Protocol];
+/**
+ * HTTP MatchMaking Error Codes
+ */
+export declare const ErrorCode: {
+	readonly MATCHMAKE_NO_HANDLER: 520;
+	readonly MATCHMAKE_INVALID_CRITERIA: 521;
+	readonly MATCHMAKE_INVALID_ROOM_ID: 522;
+	readonly MATCHMAKE_UNHANDLED: 523;
+	readonly MATCHMAKE_EXPIRED: 524;
+	readonly AUTH_FAILED: 525;
+	readonly APPLICATION_ERROR: 526;
+	readonly INVALID_PAYLOAD: 4217;
+};
+export type ErrorCode = typeof ErrorCode[keyof typeof ErrorCode];
+/**
+ * WebSocket close codes
+ * (See https://github.com/Luka967/websocket-close-codes)
+ */
+export declare const CloseCode: {
+	readonly NORMAL_CLOSURE: 1000;
+	readonly GOING_AWAY: 1001;
+	readonly NO_STATUS_RECEIVED: 1005;
+	readonly ABNORMAL_CLOSURE: 1006;
+	readonly CONSENTED: 4000;
+	readonly SERVER_SHUTDOWN: 4001;
+	readonly WITH_ERROR: 4002;
+	readonly FAILED_TO_RECONNECT: 4003;
+	readonly MAY_TRY_RECONNECT: 4010;
+};
+export type CloseCode = typeof CloseCode[keyof typeof CloseCode];
+interface ServerRoomLike<State = any, Options = any> {
+	state: State;
+	onJoin?: (client: any, options?: Options, auth?: any) => any;
+	messages?: Record<string, any>;
+	"~client"?: {
+		"~messages"?: Record<string, any>;
+	};
+}
+/**
+ * Seat reservation returned by matchmaking operations.
+ */
+interface ISeatReservation {
+	name: string;
+	sessionId: string;
+	roomId: string;
+	publicAddress?: string;
+	processId?: string;
+	reconnectionToken?: string;
+	devMode?: boolean;
+}
+type Instantiate<T> = T extends abstract new (...args: any) => infer I ? I : T;
+type IsSchema<T> = "~refId" extends keyof T ? true : false;
+type HasUsefulStatePhantom<T> = T extends {
+	"~state": infer S;
+} ? [
+	S
+] extends [
+	never
+] ? false : unknown extends S ? false : S extends object ? [
+	keyof S
+] extends [
+	never
+] ? false : true : false : false;
+type ExtractStateFromRoom<T> = T extends {
+	"~state": infer S;
+} ? HasUsefulStatePhantom<T> extends true ? S : T extends {
+	state: infer St;
+} ? IsSchema<St> extends true ? St : T : T : T extends {
+	state: infer S;
+} ? IsSchema<S> extends true ? S : T : T;
+type InferState<T, S> = [
+	S
+] extends [
+	never
+] ? Instantiate<T> extends infer I ? IsSchema<I> extends true ? I : ExtractStateFromRoom<I> : never : S;
+type NormalizeRoomType<T> = Instantiate<T> extends {
+	"~state": any;
+} ? T : any;
+type ExtractRoomMessages<T> = Instantiate<T> extends {
+	messages: infer M;
+} ? M : {};
+type ExtractRoomClientMessages<T> = Instantiate<T> extends {
+	"~client": {
+		"~messages": infer M;
+	};
+} ? M : {};
+type MessageHandlerWithFormat<T extends StandardSchemaV1 = any, Client = any, This = any> = {
+	format: T;
+	handler: (this: This, client: Client, message: StandardSchemaV1.InferOutput<T>) => void;
+};
+type MessageHandler<Client = any, This = any> = ((this: This, client: Client, message: any) => void) | MessageHandlerWithFormat<any, Client, This>;
+type ExtractMessageType<T> = T extends {
+	format: infer Format extends StandardSchemaV1;
+	handler: any;
+} ? StandardSchemaV1.InferOutput<Format> : T extends (this: any, client: any, message: infer Message) => void ? Message : any;
+type FallbackMessageHandler<Client = any, This = any> = (this: This, client: Client, type: string, message: any) => void;
+type AnyMessageHandler<Client = any, This = any> = MessageHandler<Client, This> | FallbackMessageHandler<Client, This>;
+type Messages<Room = any, Client = any> = Record<string, AnyMessageHandler<Client, Room>> & ThisType<Room>;
+interface SDKTypes<RoomTypes extends Record<string, any> = any, Routes = any> {
+	"~rooms": RoomTypes;
+	"~routes": Routes;
+}
+declare enum OPERATION {
+	ADD = 128,// (10000000) add new structure/primitive
+	REPLACE = 0,// (00000001) replace structure/primitive
+	DELETE = 64,// (01000000) delete field
+	DELETE_AND_MOVE = 96,// () ArraySchema only
+	MOVE_AND_ADD = 160,// () ArraySchema only
+	DELETE_AND_ADD = 192,// (11000000) DELETE field, followed by an ADD
+	/**
+	 * Collection operations
+	 */
+	CLEAR = 10,
+	/**
+	 * ArraySchema operations
+	 */
+	REVERSE = 15,
+	MOVE = 32,
+	DELETE_BY_REFID = 33,// This operation is only used at ENCODING time. During DECODING, DELETE_BY_REFID is converted to DELETE
+	ADD_BY_REFID = 129
+}
+declare const $refId = "~refId";
+declare const $track = "~track";
+declare const $encoder = "~encoder";
+declare const $decoder = "~decoder";
+declare const $filter = "~filter";
+declare const $getByIndex = "~getByIndex";
+declare const $deleteByIndex = "~deleteByIndex";
+declare const $changes = "~changes";
+declare const $childType = "~childType";
+declare const $onEncodeEnd = "~onEncodeEnd";
+declare const $onDecodeEnd = "~onDecodeEnd";
+declare const $descriptors = "~descriptors";
+declare const $numFields = "~__numFields";
+declare const $refTypeFieldIndexes = "~__refTypeFieldIndexes";
+declare const $viewFieldIndexes = "~__viewFieldIndexes";
+declare const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
+declare class StateView {
+	iterable: boolean;
+	/**
+	 * Iterable list of items that are visible to this view
+	 * (Available only if constructed with `iterable: true`)
+	 */
+	items: Ref[];
+	/**
+	 * List of ChangeTree's that are visible to this view
+	 */
+	visible: WeakSet<ChangeTree>;
+	/**
+	 * List of ChangeTree's that are invisible to this view
+	 */
+	invisible: WeakSet<ChangeTree>;
+	tags?: WeakMap<ChangeTree, Set<number>>;
+	/**
+	 * Manual "ADD" operations for changes per ChangeTree, specific to this view.
+	 * (This is used to force encoding a property, even if it was not changed)
+	 */
+	changes: Map<number, IndexedOperations>;
+	constructor(iterable?: boolean);
+	add(obj: Ref, tag?: number, checkIncludeParent?: boolean): boolean;
+	protected addParentOf(childChangeTree: ChangeTree, tag: number): void;
+	remove(obj: Ref, tag?: number): this;
+	remove(obj: Ref, tag?: number, _isClear?: boolean): this;
+	has(obj: Ref): boolean;
+	hasTag(ob: Ref, tag?: number): boolean;
+	clear(): void;
+	isChangeTreeVisible(changeTree: ChangeTree): boolean;
+	protected _recursiveDeleteVisibleChangeTree(changeTree: ChangeTree): void;
+}
+declare class TypeContext {
+	types: {
+		[id: number]: typeof Schema;
+	};
+	schemas: Map<typeof Schema, number>;
+	hasFilters: boolean;
+	parentFiltered: {
+		[typeIdAndParentIndex: string]: boolean;
+	};
+	/**
+	 * For inheritance support
+	 * Keeps track of which classes extends which. (parent -> children)
+	 */
+	static inheritedTypes: Map<typeof Schema, Set<typeof Schema>>;
+	static cachedContexts: Map<typeof Schema, TypeContext>;
+	static register(target: typeof Schema): void;
+	static cache(rootClass: typeof Schema): TypeContext;
+	constructor(rootClass?: typeof Schema);
+	has(schema: typeof Schema): boolean;
+	get(typeid: number): typeof Schema;
+	add(schema: typeof Schema, typeid?: number): boolean;
+	getTypeId(klass: typeof Schema): number;
+	private discoverTypes;
+	/**
+	 * Keep track of which classes have filters applied.
+	 * Format: `${typeid}-${parentTypeid}-${parentIndex}`
+	 */
+	private registerFilteredByParent;
+	debug(): string;
+}
+interface Iterator$1 {
+	offset: number;
+}
+declare class Root {
+	types: TypeContext;
+	protected nextUniqueId: number;
+	refCount: {
+		[id: number]: number;
+	};
+	changeTrees: {
+		[refId: number]: ChangeTree;
+	};
+	allChanges: ChangeTreeList;
+	allFilteredChanges: ChangeTreeList;
+	changes: ChangeTreeList;
+	filteredChanges: ChangeTreeList;
+	constructor(types: TypeContext);
+	getNextUniqueId(): number;
+	add(changeTree: ChangeTree): boolean;
+	remove(changeTree: ChangeTree): number;
+	recursivelyMoveNextToParent(changeTree: ChangeTree): void;
+	moveNextToParent(changeTree: ChangeTree): void;
+	moveNextToParentInChangeTreeList(changeSetName: ChangeSetName, changeTree: ChangeTree): void;
+	enqueueChangeTree(changeTree: ChangeTree, changeSet: "changes" | "filteredChanges" | "allFilteredChanges" | "allChanges", queueRootNode?: ChangeTreeNode): void;
+	protected addToChangeTreeList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode;
+	protected updatePositionsAfterRemoval(list: ChangeTreeList, removedPosition: number): void;
+	protected updatePositionsAfterMove(list: ChangeTreeList, node: ChangeTreeNode, newPosition: number): void;
+	removeChangeFromChangeSet(changeSetName: ChangeSetName, changeTree: ChangeTree): boolean;
+}
+declare class Encoder<T extends Schema = any> {
+	static BUFFER_SIZE: number;
+	sharedBuffer: Uint8Array;
+	context: TypeContext;
+	state: T;
+	root: Root;
+	constructor(state: T);
+	protected setState(state: T): void;
+	encode(it?: Iterator$1, view?: StateView, buffer?: Uint8Array, changeSetName?: ChangeSetName, isEncodeAll?: boolean, initialOffset?: number): Uint8Array;
+	encodeAll(it?: Iterator$1, buffer?: Uint8Array): Uint8Array<ArrayBufferLike>;
+	encodeAllView(view: StateView, sharedOffset: number, it: Iterator$1, bytes?: Uint8Array): Uint8Array<ArrayBufferLike>;
+	encodeView(view: StateView, sharedOffset: number, it: Iterator$1, bytes?: Uint8Array): Uint8Array<ArrayBufferLike>;
+	discardChanges(): void;
+	tryEncodeTypeId(bytes: Uint8Array, baseType: typeof Schema, targetType: typeof Schema, it: Iterator$1): void;
+	get hasChanges(): boolean;
+}
+type MetadataField = {
+	type: DefinitionType;
+	name: string;
+	index: number;
+	tag?: number;
+	unreliable?: boolean;
+	deprecated?: boolean;
+};
+type Metadata = {
+	[$numFields]: number;
+} & // number of fields
+{
+	[$viewFieldIndexes]: number[];
+} & // all field indexes with "view" tag
+{
+	[$fieldIndexesByViewTag]: {
+		[tag: number]: number[];
+	};
+} & // field indexes by "view" tag
+{
+	[$refTypeFieldIndexes]: number[];
+} & // all field indexes containing Ref types (Schema, ArraySchema, MapSchema, etc)
+{
+	[field: number]: MetadataField;
+} & // index => field name
+{
+	[field: string]: number;
+} & // field name => field metadata
+{
+	[$descriptors]: {
+		[field: string]: PropertyDescriptor;
+	};
+};
+declare const Metadata: {
+	addField(metadata: any, index: number, name: string, type: DefinitionType, descriptor?: PropertyDescriptor): void;
+	setTag(metadata: Metadata, fieldName: string, tag: number): void;
+	setFields<T extends {
+		new (...args: any[]): InstanceType<T>;
+	} = any>(target: T, fields: {
+		[field in keyof InstanceType<T>]?: DefinitionType;
+	}): T;
+	isDeprecated(metadata: any, field: string): boolean;
+	init(klass: any): void;
+	initialize(constructor: any): Metadata;
+	isValidInstance(klass: any): boolean;
+	getFields(klass: any): any;
+	hasViewTagAtIndex(metadata: Metadata, index: number): boolean;
+};
+type EncodeOperation<T extends Ref = any> = (encoder: Encoder, bytes: Uint8Array, changeTree: ChangeTree<T>, index: number, operation: OPERATION, it: Iterator$1, isEncodeAll: boolean, hasView: boolean, metadata?: Metadata) => void;
+type SchemaCallbacks = {
+	[field: string | number]: Function[];
+};
+declare class ReferenceTracker {
+	refs: Map<number, IRef>;
+	refCount: {
+		[refId: number]: number;
+	};
+	deletedRefs: Set<number>;
+	callbacks: {
+		[refId: number]: SchemaCallbacks;
+	};
+	protected nextUniqueId: number;
+	getNextUniqueId(): number;
+	addRef(refId: number, ref: IRef, incrementCount?: boolean): void;
+	removeRef(refId: number): void;
+	clearRefs(): void;
+	garbageCollectDeletedRefs(): void;
+	addCallback(refId: number, fieldOrOperation: string | number, callback: Function): () => void;
+	removeCallback(refId: number, field: string | number, callback: Function): void;
+}
+declare class Decoder<T extends IRef = any> {
+	context: TypeContext;
+	state: T;
+	root: ReferenceTracker;
+	currentRefId: number;
+	triggerChanges?: (allChanges: DataChange[]) => void;
+	constructor(root: T, context?: TypeContext);
+	protected setState(root: T): void;
+	decode(bytes: Uint8Array, it?: Iterator$1, ref?: IRef): DataChange<any, string>[];
+	skipCurrentStructure(bytes: Uint8Array, it: Iterator$1, totalBytes: number): void;
+	getInstanceType(bytes: Uint8Array, it: Iterator$1, defaultType: typeof Schema): typeof Schema;
+	createInstanceOfType(type: typeof Schema): Schema;
+	removeChildRefs(ref: Collection, allChanges: DataChange[]): void;
+}
+interface DataChange<T = any, F = string> {
+	ref: IRef;
+	refId: number;
+	op: OPERATION;
+	field: F;
+	dynamicIndex?: number | string;
+	value: T;
+	previousValue: T;
+}
+type DecodeOperation<T extends Schema = any> = (decoder: Decoder<T>, bytes: Uint8Array, it: Iterator$1, ref: IRef, allChanges: DataChange[]) => number | void;
+type K = number;
+declare class CollectionSchema<V = any> implements Collection<K, V>, IRef {
+	[$changes]: ChangeTree;
+	[$refId]?: number;
+	protected [$childType]: string | typeof Schema;
+	protected $items: Map<number, V>;
+	protected $indexes: Map<number, number>;
+	protected deletedItems: {
+		[field: string]: V;
+	};
+	protected $refId: number;
+	static [$encoder]: EncodeOperation<any>;
+	static [$decoder]: DecodeOperation<any>;
+	/**
+	 * Determine if a property must be filtered.
+	 * - If returns false, the property is NOT going to be encoded.
+	 * - If returns true, the property is going to be encoded.
+	 *
+	 * Encoding with "filters" happens in two steps:
+	 * - First, the encoder iterates over all "not owned" properties and encodes them.
+	 * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+	 */
+	static [$filter](ref: CollectionSchema, index: number, view: StateView): boolean;
+	static is(type: any): boolean;
+	constructor(initialValues?: Array<V>);
+	add(value: V): number;
+	at(index: number): V | undefined;
+	entries(): MapIterator<[
+		number,
+		V
+	]>;
+	delete(item: V): boolean;
+	clear(): void;
+	has(value: V): boolean;
+	forEach(callbackfn: (value: V, key: K, collection: CollectionSchema<V>) => void): void;
+	values(): MapIterator<V>;
+	get size(): number;
+	/** Iterator */
+	[Symbol.iterator](): IterableIterator<V>;
+	protected setIndex(index: number, key: number): void;
+	protected getIndex(index: number): number;
+	[$getByIndex](index: number): any;
+	[$deleteByIndex](index: number): void;
+	protected [$onEncodeEnd](): void;
+	toArray(): V[];
+	toJSON(): V[];
+	clone(isDecoding?: boolean): CollectionSchema<V>;
+}
+declare class SetSchema<V = any> implements Collection<number, V>, IRef {
+	[$changes]: ChangeTree;
+	[$refId]?: number;
+	protected [$childType]: string | typeof Schema;
+	protected $items: Map<number, V>;
+	protected $indexes: Map<number, number>;
+	protected deletedItems: {
+		[field: string]: V;
+	};
+	protected $refId: number;
+	static [$encoder]: EncodeOperation<any>;
+	static [$decoder]: DecodeOperation<any>;
+	/**
+	 * Determine if a property must be filtered.
+	 * - If returns false, the property is NOT going to be encoded.
+	 * - If returns true, the property is going to be encoded.
+	 *
+	 * Encoding with "filters" happens in two steps:
+	 * - First, the encoder iterates over all "not owned" properties and encodes them.
+	 * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+	 */
+	static [$filter](ref: SetSchema, index: number, view: StateView): boolean;
+	static is(type: any): boolean;
+	constructor(initialValues?: Array<V>);
+	add(value: V): number | false;
+	entries(): MapIterator<[
+		number,
+		V
+	]>;
+	delete(item: V): boolean;
+	clear(): void;
+	has(value: V): boolean;
+	forEach(callbackfn: (value: V, key: number, collection: SetSchema<V>) => void): void;
+	values(): MapIterator<V>;
+	get size(): number;
+	/** Iterator */
+	[Symbol.iterator](): IterableIterator<V>;
+	protected setIndex(index: number, key: number): void;
+	protected getIndex(index: number): number;
+	[$getByIndex](index: number): any;
+	[$deleteByIndex](index: number): void;
+	protected [$onEncodeEnd](): void;
+	toArray(): V[];
+	toJSON(): V[];
+	clone(isDecoding?: boolean): SetSchema<V>;
+}
+type Constructor<T = {}> = new (...args: any[]) => T;
+type PrimitiveStringToType<T> = T extends "string" ? string : T extends "number" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "float32" | "float64" ? number : T extends "boolean" ? boolean : T;
+interface Collection<K = any, V = any, IT = V> {
+	[Symbol.iterator](): IterableIterator<IT>;
+	forEach(callback: Function): void;
+	entries(): IterableIterator<[
+		K,
+		V
+	]>;
+}
+type InferValueType<T extends DefinitionType> = T extends "string" ? string : T extends "number" ? number : T extends "int8" ? number : T extends "uint8" ? number : T extends "int16" ? number : T extends "uint16" ? number : T extends "int32" ? number : T extends "uint32" ? number : T extends "int64" ? number : T extends "uint64" ? number : T extends "float32" ? number : T extends "float64" ? number : T extends "boolean" ? boolean : T extends {
+	type: infer ChildType extends PrimitiveType;
+} ? InferValueType<ChildType> : T extends {
+	type: infer ChildType extends Constructor;
+} ? InstanceType<ChildType> : T extends {
+	type: Array<infer ChildType>;
+} ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) : T extends {
+	type: {
+		map: infer ChildType;
+	};
+} ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<ChildType>) : T extends {
+	type: {
+		set: infer ChildType;
+	};
+} ? (ChildType extends Record<string | number, string | number> ? SetSchema<ChildType[keyof ChildType]> : SetSchema<ChildType>) : T extends {
+	type: {
+		collection: infer ChildType;
+	};
+} ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) : T extends {
+	type: infer ChildType;
+} ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType] : ChildType) : T extends Array<infer ChildType extends Constructor> ? ArraySchema<InstanceType<ChildType>> : T extends Array<infer ChildType> ? (ChildType extends Record<string | number, string | number> ? ArraySchema<ChildType[keyof ChildType]> : ArraySchema<PrimitiveStringToType<ChildType>>) : T extends {
+	array: infer ChildType extends Constructor;
+} ? ArraySchema<InstanceType<ChildType>> : T extends {
+	array: infer ChildType;
+} ? (ChildType extends Record<string | number, string | number> ? ArraySchema<ChildType[keyof ChildType]> : ArraySchema<PrimitiveStringToType<ChildType>>) : T extends {
+	map: infer ChildType extends Constructor;
+} ? MapSchema<InstanceType<ChildType>> : T extends {
+	map: infer ChildType;
+} ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<PrimitiveStringToType<ChildType>>) : T extends {
+	set: infer ChildType extends Constructor;
+} ? SetSchema<InstanceType<ChildType>> : T extends {
+	set: infer ChildType extends RawPrimitiveType;
+} ? SetSchema<InferValueType<ChildType>> : T extends {
+	set: infer ChildType;
+} ? (ChildType extends Record<string | number, string | number> ? SetSchema<ChildType[keyof ChildType]> : SetSchema<ChildType>) : T extends {
+	collection: infer ChildType extends Constructor;
+} ? CollectionSchema<InstanceType<ChildType>> : T extends {
+	collection: infer ChildType extends RawPrimitiveType;
+} ? CollectionSchema<InferValueType<ChildType>> : T extends {
+	collection: infer ChildType;
+} ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) : T extends Constructor ? InstanceType<T> : T extends Record<string | number, string | number> ? T[keyof T] : T extends PrimitiveType ? T : never;
+type NonFunctionProps<T> = Omit<T, {
+	[K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T]>;
+type NonFunctionPropNames<T> = {
+	[K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+type NonFunctionNonPrimitivePropNames<T> = {
+	[K in keyof T]: T[K] extends Function ? never : T[K] extends number | string | boolean ? never : K;
+}[keyof T];
+type ToJSONValue<U> = U extends Schema ? ToJSON<U> : PrimitiveStringToType<U>;
+type ToJSON<T> = NonFunctionProps<{
+	[K in keyof T]: T[K] extends MapSchema<infer U> ? Record<string, ToJSONValue<U>> : T[K] extends Map<string, infer U> ? Record<string, ToJSONValue<U>> : T[K] extends ArraySchema<infer U> ? ToJSONValue<U>[] : T[K] extends SetSchema<infer U> ? ToJSONValue<U>[] : T[K] extends CollectionSchema<infer U> ? ToJSONValue<U>[] : T[K] extends Schema ? ToJSON<T[K]> : T[K];
+}>;
+type AssignableProps<T> = {
+	[K in NonFunctionPropNames<T>]?: T[K] extends MapSchema<infer U> ? MapSchema<U> | Record<string, U extends Schema ? (U | AssignableProps<U>) : U> : T[K] extends ArraySchema<infer U> ? ArraySchema<U> | (U extends Schema ? (U | AssignableProps<U>)[] : U[]) : T[K] extends SetSchema<infer U> ? SetSchema<U> | Set<U> | (U extends Schema ? (U | AssignableProps<U>)[] : U[]) : T[K] extends CollectionSchema<infer U> ? CollectionSchema<U> | (U extends Schema ? (U | AssignableProps<U>)[] : U[]) : T[K] extends Schema ? T[K] | AssignableProps<T[K]> : T[K];
+};
+declare class MapSchema<V = any, K extends string = string> implements Map<K, V>, Collection<K, V, [
+	K,
+	V
+]>, IRef {
+	[$changes]: ChangeTree;
+	[$refId]?: number;
+	protected childType: new () => V;
+	protected [$childType]: string | typeof Schema;
+	protected $items: Map<K, V>;
+	protected $indexes: Map<number, K>;
+	protected deletedItems: {
+		[index: string]: V;
+	};
+	static [$encoder]: EncodeOperation<any>;
+	static [$decoder]: DecodeOperation<any>;
+	/**
+	 * Determine if a property must be filtered.
+	 * - If returns false, the property is NOT going to be encoded.
+	 * - If returns true, the property is going to be encoded.
+	 *
+	 * Encoding with "filters" happens in two steps:
+	 * - First, the encoder iterates over all "not owned" properties and encodes them.
+	 * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+	 */
+	static [$filter](ref: MapSchema, index: number, view: StateView): boolean;
+	static is(type: any): boolean;
+	constructor(initialValues?: Map<K, V> | Record<K, V>);
+	/** Iterator */
+	[Symbol.iterator](): IterableIterator<[
+		K,
+		V
+	]>;
+	get [Symbol.toStringTag](): string;
+	static get [Symbol.species](): typeof MapSchema;
+	set(key: K, value: V): this;
+	get(key: K): V | undefined;
+	delete(key: K): boolean;
+	clear(): void;
+	has(key: K): boolean;
+	forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void): void;
+	entries(): MapIterator<[
+		K,
+		V
+	]>;
+	keys(): MapIterator<K>;
+	values(): MapIterator<V>;
+	get size(): number;
+	protected setIndex(index: number, key: K): void;
+	protected getIndex(index: number): K;
+	[$getByIndex](index: number): V | undefined;
+	[$deleteByIndex](index: number): void;
+	protected [$onEncodeEnd](): void;
+	toJSON(): any;
+	clone(isDecoding?: boolean): MapSchema<V>;
+}
+interface IRef {
+	[$refId]?: number;
+	[$getByIndex]?: (index: number, isEncodeAll?: boolean) => any;
+	[$deleteByIndex]?: (index: number) => void;
+}
+type Ref = Schema | ArraySchema | MapSchema | CollectionSchema | SetSchema;
+type ChangeSetName = "changes" | "allChanges" | "filteredChanges" | "allFilteredChanges";
+interface IndexedOperations {
+	[index: number]: OPERATION;
+}
+interface ChangeTreeNode {
+	changeTree: ChangeTree;
+	next?: ChangeTreeNode;
+	prev?: ChangeTreeNode;
+	position: number;
+}
+interface ChangeTreeList {
+	next?: ChangeTreeNode;
+	tail?: ChangeTreeNode;
+}
+interface ChangeSet {
+	indexes: {
+		[index: number]: number;
+	};
+	operations: number[];
+	queueRootNode?: ChangeTreeNode;
+}
+interface ParentChain {
+	ref: Ref;
+	index: number;
+	next?: ParentChain;
+}
+declare class ChangeTree<T extends Ref = any> {
+	ref: T;
+	metadata: Metadata;
+	root?: Root;
+	parentChain?: ParentChain;
+	/**
+	 * Whether this structure is parent of a filtered structure.
+	 */
+	isFiltered: boolean;
+	isVisibilitySharedWithParent?: boolean;
+	indexedOperations: IndexedOperations;
+	changes: ChangeSet;
+	allChanges: ChangeSet;
+	filteredChanges: ChangeSet;
+	allFilteredChanges: ChangeSet;
+	indexes: {
+		[index: string]: any;
+	};
+	/**
+	 * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+	 */
+	isNew: boolean;
+	constructor(ref: T);
+	setRoot(root: Root): void;
+	setParent(parent: Ref, root?: Root, parentIndex?: number): void;
+	forEachChild(callback: (change: ChangeTree, at: any) => void): void;
+	operation(op: OPERATION): void;
+	change(index: number, operation?: OPERATION): void;
+	shiftChangeIndexes(shiftIndex: number): void;
+	shiftAllChangeIndexes(shiftIndex: number, startIndex?: number): void;
+	private _shiftAllChangeIndexes;
+	indexedOperation(index: number, operation: OPERATION, allChangesIndex?: number): void;
+	getType(index?: number): any;
+	getChange(index: number): OPERATION;
+	getValue(index: number, isEncodeAll?: boolean): any;
+	delete(index: number, operation?: OPERATION, allChangesIndex?: number): any;
+	endEncode(changeSetName: ChangeSetName): void;
+	discard(discardAll?: boolean): void;
+	/**
+	 * Recursively discard all changes from this, and child structures.
+	 * (Used in tests only)
+	 */
+	discardAll(): void;
+	get changed(): boolean;
+	protected checkIsFiltered(parent: Ref, parentIndex: number, isNewChangeTree: boolean): void;
+	protected _checkFilteredByParent(parent: Ref, parentIndex: number): void;
+	/**
+	 * Get the immediate parent
+	 */
+	get parent(): Ref | undefined;
+	/**
+	 * Get the immediate parent index
+	 */
+	get parentIndex(): number | undefined;
+	/**
+	 * Add a parent to the chain
+	 */
+	addParent(parent: Ref, index: number): void;
+	/**
+	 * Remove a parent from the chain
+	 * @param parent - The parent to remove
+	 * @returns true if parent was removed
+	 */
+	removeParent(parent?: Ref): boolean;
+	/**
+	 * Find a specific parent in the chain
+	 */
+	findParent(predicate: (parent: Ref, index: number) => boolean): ParentChain | undefined;
+	/**
+	 * Check if this ChangeTree has a specific parent
+	 */
+	hasParent(predicate: (parent: Ref, index: number) => boolean): boolean;
+	/**
+	 * Get all parents as an array (for debugging/testing)
+	 */
+	getAllParents(): Array<{
+		ref: Ref;
+		index: number;
+	}>;
+}
+declare class ArraySchema<V = any> implements Array<V>, Collection<number, V>, IRef {
+	[n: number]: V;
+	[$changes]: ChangeTree;
+	[$refId]?: number;
+	protected [$childType]: string | typeof Schema;
+	protected items: V[];
+	protected tmpItems: V[];
+	protected deletedIndexes: {
+		[index: number]: boolean;
+	};
+	protected isMovingItems: boolean;
+	static [$encoder]: EncodeOperation<any>;
+	static [$decoder]: DecodeOperation<any>;
+	/**
+	 * Determine if a property must be filtered.
+	 * - If returns false, the property is NOT going to be encoded.
+	 * - If returns true, the property is going to be encoded.
+	 *
+	 * Encoding with "filters" happens in two steps:
+	 * - First, the encoder iterates over all "not owned" properties and encodes them.
+	 * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+	 */
+	static [$filter](ref: ArraySchema, index: number, view: StateView): boolean;
+	static is(type: any): boolean;
+	static from<T>(iterable: Iterable<T> | ArrayLike<T>): ArraySchema<T>;
+	constructor(...items: V[]);
+	set length(newLength: number);
+	get length(): number;
+	push(...values: V[]): number;
+	/**
+	 * Removes the last element from an array and returns it.
+	 */
+	pop(): V | undefined;
+	at(index: number): V;
+	protected $changeAt(index: number, value: V): void;
+	protected $deleteAt(index: number, operation?: OPERATION): void;
+	protected $setAt(index: number, value: V, operation: OPERATION): void;
+	clear(): void;
+	/**
+	 * Combines two or more arrays.
+	 * @param items Additional items to add to the end of array1.
+	 */
+	concat(...items: (V | ConcatArray<V>)[]): ArraySchema<V>;
+	/**
+	 * Adds all the elements of an array separated by the specified separator string.
+	 * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
+	 */
+	join(separator?: string): string;
+	/**
+	 * Reverses the elements in an Array.
+	 */
+	reverse(): ArraySchema<V>;
+	/**
+	 * Removes the first element from an array and returns it.
+	 */
+	shift(): V | undefined;
+	/**
+	 * Returns a section of an array.
+	 * @param start The beginning of the specified portion of the array.
+	 * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
+	 */
+	slice(start?: number, end?: number): V[];
+	/**
+	 * Sorts an array.
+	 * @param compareFn Function used to determine the order of the elements. It is expected to return
+	 * a negative value if first argument is less than second argument, zero if they're equal and a positive
+	 * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+	 * ```ts
+	 * [11,2,22,1].sort((a, b) => a - b)
+	 * ```
+	 */
+	sort(compareFn?: (a: V, b: V) => number): this;
+	/**
+	 * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
+	 * @param start The zero-based location in the array from which to start removing elements.
+	 * @param deleteCount The number of elements to remove.
+	 * @param insertItems Elements to insert into the array in place of the deleted elements.
+	 */
+	splice(start: number, deleteCount?: number, ...insertItems: V[]): V[];
+	/**
+	 * Inserts new elements at the start of an array.
+	 * @param items  Elements to insert at the start of the Array.
+	 */
+	unshift(...items: V[]): number;
+	/**
+	 * Returns the index of the first occurrence of a value in an array.
+	 * @param searchElement The value to locate in the array.
+	 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
+	 */
+	indexOf(searchElement: V, fromIndex?: number): number;
+	/**
+	 * Returns the index of the last occurrence of a specified value in an array.
+	 * @param searchElement The value to locate in the array.
+	 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array.
+	 */
+	lastIndexOf(searchElement: V, fromIndex?: number): number;
+	/**
+	 * Determines whether all the members of an array satisfy the specified test.
+	 * @param callbackfn A function that accepts up to three arguments. The every method calls
+	 * the callbackfn function for each element in the array until the callbackfn returns a value
+	 * which is coercible to the Boolean value false, or until the end of the array.
+	 * @param thisArg An object to which the this keyword can refer in the callbackfn function.
+	 * If thisArg is omitted, undefined is used as the this value.
+	 */
+	every<S extends V>(predicate: (value: V, index: number, array: V[]) => value is S, thisArg?: any): this is S[];
+	every(callbackfn: (value: V, index: number, array: V[]) => unknown, thisArg?: any): boolean;
+	/**
+	 * Determines whether the specified callback function returns true for any element of an array.
+	 * @param callbackfn A function that accepts up to three arguments. The some method calls
+	 * the callbackfn function for each element in the array until the callbackfn returns a value
+	 * which is coercible to the Boolean value true, or until the end of the array.
+	 * @param thisArg An object to which the this keyword can refer in the callbackfn function.
+	 * If thisArg is omitted, undefined is used as the this value.
+	 */
+	some(callbackfn: (value: V, index: number, array: V[]) => unknown, thisArg?: any): boolean;
+	/**
+	 * Performs the specified action for each element in an array.
+	 * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
+	 * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+	 */
+	forEach(callbackfn: (value: V, index: number, array: V[]) => void, thisArg?: any): void;
+	/**
+	 * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+	 * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
+	 * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+	 */
+	map<U>(callbackfn: (value: V, index: number, array: V[]) => U, thisArg?: any): U[];
+	/**
+	 * Returns the elements of an array that meet the condition specified in a callback function.
+	 * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
+	 * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+	 */
+	filter(callbackfn: (value: V, index: number, array: V[]) => unknown, thisArg?: any): V[];
+	/**
+	 * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+	 * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
+	 * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+	 */
+	reduce<U = V>(callbackfn: (previousValue: U, currentValue: V, currentIndex: number, array: V[]) => U, initialValue?: U): U;
+	/**
+	 * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
+	 * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
+	 * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
+	 */
+	reduceRight<U = V>(callbackfn: (previousValue: U, currentValue: V, currentIndex: number, array: V[]) => U, initialValue?: U): U;
+	/**
+	 * Returns the value of the first element in the array where predicate is true, and undefined
+	 * otherwise.
+	 * @param predicate find calls predicate once for each element of the array, in ascending
+	 * order, until it finds one where predicate returns true. If such an element is found, find
+	 * immediately returns that element value. Otherwise, find returns undefined.
+	 * @param thisArg If provided, it will be used as the this value for each invocation of
+	 * predicate. If it is not provided, undefined is used instead.
+	 */
+	find(predicate: (value: V, index: number, obj: V[]) => boolean, thisArg?: any): V | undefined;
+	/**
+	 * Returns the index of the first element in the array where predicate is true, and -1
+	 * otherwise.
+	 * @param predicate find calls predicate once for each element of the array, in ascending
+	 * order, until it finds one where predicate returns true. If such an element is found,
+	 * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+	 * @param thisArg If provided, it will be used as the this value for each invocation of
+	 * predicate. If it is not provided, undefined is used instead.
+	 */
+	findIndex(predicate: (value: V, index: number, obj: V[]) => unknown, thisArg?: any): number;
+	/**
+	 * Returns the this object after filling the section identified by start and end with value
+	 * @param value value to fill array section with
+	 * @param start index to start filling the array at. If start is negative, it is treated as
+	 * length+start where length is the length of the array.
+	 * @param end index to stop filling the array at. If end is negative, it is treated as
+	 * length+end.
+	 */
+	fill(value: V, start?: number, end?: number): this;
+	/**
+	 * Returns the this object after copying a section of the array identified by start and end
+	 * to the same array starting at position target
+	 * @param target If target is negative, it is treated as length+target where length is the
+	 * length of the array.
+	 * @param start If start is negative, it is treated as length+start. If end is negative, it
+	 * is treated as length+end.
+	 * @param end If not specified, length of the this object is used as its default value.
+	 */
+	copyWithin(target: number, start: number, end?: number): this;
+	/**
+	 * Returns a string representation of an array.
+	 */
+	toString(): string;
+	/**
+	 * Returns a string representation of an array. The elements are converted to string using their toLocalString methods.
+	 */
+	toLocaleString(): string;
+	/** Iterator */
+	[Symbol.iterator](): ArrayIterator<V>;
+	static get [Symbol.species](): typeof ArraySchema;
+	[Symbol.unscopables]: any;
+	/**
+	 * Returns an iterable of key, value pairs for every entry in the array
+	 */
+	entries(): ArrayIterator<[
+		number,
+		V
+	]>;
+	/**
+	 * Returns an iterable of keys in the array
+	 */
+	keys(): ArrayIterator<number>;
+	/**
+	 * Returns an iterable of values in the array
+	 */
+	values(): ArrayIterator<V>;
+	/**
+	 * Determines whether an array includes a certain element, returning true or false as appropriate.
+	 * @param searchElement The element to search for.
+	 * @param fromIndex The position in this array at which to begin searching for searchElement.
+	 */
+	includes(searchElement: V, fromIndex?: number): boolean;
+	/**
+	 * Calls a defined callback function on each element of an array. Then, flattens the result into
+	 * a new array.
+	 * This is identical to a map followed by flat with depth 1.
+	 *
+	 * @param callback A function that accepts up to three arguments. The flatMap method calls the
+	 * callback function one time for each element in the array.
+	 * @param thisArg An object to which the this keyword can refer in the callback function. If
+	 * thisArg is omitted, undefined is used as the this value.
+	 */
+	flatMap<U, This = undefined>(callback: (this: This, value: V, index: number, array: V[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
+	/**
+	 * Returns a new array with all sub-array elements concatenated into it recursively up to the
+	 * specified depth.
+	 *
+	 * @param depth The maximum recursion depth
+	 */
+	flat<A, D extends number = 1>(this: A, depth?: D): any;
+	findLast(): any;
+	findLastIndex(...args: any[]): any;
+	with(index: number, value: V): ArraySchema<V>;
+	toReversed(): V[];
+	toSorted(compareFn?: (a: V, b: V) => number): V[];
+	toSpliced(start: number, deleteCount: number, ...items: V[]): V[];
+	toSpliced(start: number, deleteCount?: number): V[];
+	shuffle(): this;
+	/**
+	 * Allows to move items around in the array.
+	 *
+	 * Example:
+	 *     state.cards.move((cards) => {
+	 *         [cards[4], cards[3]] = [cards[3], cards[4]];
+	 *         [cards[3], cards[2]] = [cards[2], cards[3]];
+	 *         [cards[2], cards[0]] = [cards[0], cards[2]];
+	 *         [cards[1], cards[1]] = [cards[1], cards[1]];
+	 *         [cards[0], cards[0]] = [cards[0], cards[0]];
+	 *     })
+	 *
+	 * @param cb
+	 * @returns
+	 */
+	move(cb: (arr: this) => void): this;
+	[$getByIndex](index: number, isEncodeAll?: boolean): any;
+	[$deleteByIndex](index: number): void;
+	protected [$onEncodeEnd](): void;
+	protected [$onDecodeEnd](): void;
+	toArray(): V[];
+	toJSON(): any[];
+	clone(isDecoding?: boolean): ArraySchema<V>;
+}
+type RawPrimitiveType = "string" | "number" | "boolean" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "float32" | "float64" | "bigint64" | "biguint64";
+type PrimitiveType = RawPrimitiveType | typeof Schema | object;
+type DefinitionType<T extends PrimitiveType = PrimitiveType> = T | T[] | {
+	type: T;
+	default?: InferValueType<T>;
+	view?: boolean | number;
+	sync?: boolean;
+} | {
+	array: T;
+	default?: ArraySchema<InferValueType<T>>;
+	view?: boolean | number;
+	sync?: boolean;
+} | {
+	map: T;
+	default?: MapSchema<InferValueType<T>>;
+	view?: boolean | number;
+	sync?: boolean;
+} | {
+	collection: T;
+	default?: CollectionSchema<InferValueType<T>>;
+	view?: boolean | number;
+	sync?: boolean;
+} | {
+	set: T;
+	default?: SetSchema<InferValueType<T>>;
+	view?: boolean | number;
+	sync?: boolean;
+};
+declare class Schema<C = any> implements IRef {
+	static [Symbol.metadata]: Metadata;
+	static [$encoder]: EncodeOperation<any>;
+	static [$decoder]: DecodeOperation<any>;
+	[$refId]?: number;
+	/**
+	 * Assign the property descriptors required to track changes on this instance.
+	 * @param instance
+	 */
+	static initialize(instance: any): void;
+	static is(type: DefinitionType): boolean;
+	/**
+	 * Check if a value is an instance of Schema.
+	 * This method uses duck-typing to avoid issues with multiple @colyseus/schema versions.
+	 * @param obj Value to check
+	 * @returns true if the value is a Schema instance
+	 */
+	static isSchema(obj: any): obj is Schema;
+	/**
+	 * Track property changes
+	 */
+	static [$track](changeTree: ChangeTree, index: number, operation?: OPERATION): void;
+	/**
+	 * Determine if a property must be filtered.
+	 * - If returns false, the property is NOT going to be encoded.
+	 * - If returns true, the property is going to be encoded.
+	 *
+	 * Encoding with "filters" happens in two steps:
+	 * - First, the encoder iterates over all "not owned" properties and encodes them.
+	 * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+	 */
+	static [$filter](ref: Schema, index: number, view: StateView): boolean;
+	constructor(arg?: C);
+	/**
+	 * Assign properties to the instance.
+	 * @param props Properties to assign to the instance
+	 * @returns
+	 */
+	assign<T extends Partial<this>>(props: AssignableProps<T>): this;
+	/**
+	 * Restore the instance from JSON data.
+	 * @param jsonData JSON data to restore the instance from
+	 * @returns
+	 */
+	restore(jsonData: ToJSON<this>): this;
+	/**
+	 * (Server-side): Flag a property to be encoded for the next patch.
+	 * @param instance Schema instance
+	 * @param property string representing the property name, or number representing the index of the property.
+	 * @param operation OPERATION to perform (detected automatically)
+	 */
+	setDirty<K extends NonFunctionPropNames<this>>(property: K | number, operation?: OPERATION): void;
+	clone(): this;
+	toJSON(this: any): ToJSON<this>;
+	/**
+	 * Used in tests only
+	 * @internal
+	 */
+	discardAllChanges(): void;
+	[$getByIndex](index: number): any;
+	[$deleteByIndex](index: number): void;
+	/**
+	 * Inspect the `refId` of all Schema instances in the tree. Optionally display the contents of the instance.
+	 *
+	 * @param ref Schema instance
+	 * @param showContents display JSON contents of the instance
+	 * @returns
+	 */
+	static debugRefIds<T extends Schema>(ref: T, showContents?: boolean, level?: number, decoder?: Decoder, keyPrefix?: string): string;
+	static debugRefIdEncodingOrder<T extends Ref>(ref: T, changeSet?: ChangeSetName): number[];
+	static debugRefIdsFromDecoder(decoder: Decoder): string;
+	/**
+	 * Return a string representation of the changes on a Schema instance.
+	 * The list of changes is cleared after each encode.
+	 *
+	 * @param instance Schema instance
+	 * @param isEncodeAll Return "full encode" instead of current change set.
+	 * @returns
+	 */
+	static debugChanges<T extends Ref>(instance: T, isEncodeAll?: boolean): string;
+	static debugChangesDeep<T extends Schema>(ref: T, changeSetName?: "changes" | "allChanges" | "allFilteredChanges" | "filteredChanges"): string;
+}
+type SchemaCallbackProxy<RoomState> = (<T>(instance: T) => CallbackProxy<T>);
+type CallbackProxy<T> = unknown extends T ? SchemaCallback<T> & CollectionCallback<any, any> : T extends Collection<infer K, infer V, infer _> ? CollectionCallback<K, V> : SchemaCallback<T>;
+type SchemaCallback<T> = {
+	/**
+	 * Trigger callback when value of a property changes.
+	 *
+	 * @param prop name of the property
+	 * @param callback callback to be triggered on property change
+	 * @param immediate trigger immediatelly if property has been already set.
+	 * @return callback to detach the listener
+	 */
+	listen<K extends NonFunctionPropNames<T>>(prop: K, callback: (value: T[K], previousValue: T[K]) => void, immediate?: boolean): () => void;
+	/**
+	 * Trigger callback whenever any property changed within this instance.
+	 *
+	 * @param prop name of the property
+	 * @param callback callback to be triggered on property change
+	 * @param immediate trigger immediatelly if property has been already set.
+	 * @return callback to detach the listener
+	 */
+	onChange(callback: () => void): () => void;
+	/**
+	 * Bind properties to another object. Changes on the properties will be reflected on the target object.
+	 *
+	 * @param targetObject object to bind properties to
+	 * @param properties list of properties to bind. If not provided, all properties will be bound.
+	 */
+	bindTo(targetObject: any, properties?: Array<NonFunctionPropNames<T>>): void;
+} & {
+	[K in NonFunctionNonPrimitivePropNames<T>]: CallbackProxy<T[K]>;
+};
+type CollectionCallback<K, V> = {
+	/**
+	 * Trigger callback when an item has been added to the collection.
+	 *
+	 * @param callback
+	 * @param immediate
+	 * @return callback to detach the onAdd listener
+	 */
+	onAdd(callback: (item: V, index: K) => void, immediate?: boolean): () => void;
+	/**
+	 * Trigger callback when an item has been removed to the collection.
+	 *
+	 * @param callback
+	 * @return callback to detach the onRemove listener
+	 */
+	onRemove(callback: (item: V, index: K) => void): () => void;
+	/**
+	 * Trigger callback when the value on a key has changed.
+	 *
+	 * THIS METHOD IS NOT RECURSIVE!
+	 * If you want to listen to changes on individual items, you need to attach callbacks to the them directly inside the `onAdd` callback.
+	 *
+	 * @param callback
+	 * @return callback to detach the onChange listener
+	 */
+	onChange(callback: (item: V, index: K) => void): () => void;
+};
+type PropertyChangeCallback<K> = (currentValue: K, previousValue: K) => void;
+type KeyValueCallback<K, V> = (key: K, value: V) => void;
+type ValueKeyCallback<V, K> = (value: V, key: K) => void;
+type InstanceChangeCallback = () => void;
+type PublicPropNames<T> = Exclude<NonFunctionPropNames<T>, typeof $refId> & string;
+type CollectionPropNames<T> = Exclude<{
+	[K in keyof T]: T[K] extends Collection<any, any> ? K : never;
+}[keyof T] & string, typeof $refId>;
+type CollectionValueType<T, K extends keyof T> = T[K] extends MapSchema<infer V, any> ? V : T[K] extends ArraySchema<infer V> ? V : T[K] extends Collection<any, infer V, any> ? V : never;
+type CollectionKeyType<T, K extends keyof T> = T[K] extends MapSchema<any, infer Key> ? Key : T[K] extends ArraySchema<any> ? number : T[K] extends Collection<infer Key, any, any> ? Key : never;
+declare class StateCallbackStrategy<TState extends IRef> {
+	protected decoder: Decoder<TState>;
+	protected uniqueRefIds: Set<number>;
+	protected isTriggering: boolean;
+	constructor(decoder: Decoder<TState>);
+	protected get callbacks(): {
+		[refId: number]: SchemaCallbacks;
+	};
+	protected get state(): TState;
+	protected addCallback(refId: number, operationOrProperty: OPERATION | string, handler: Function): () => void;
+	protected addCallbackOrWaitCollectionAvailable<TInstance extends IRef, TReturn extends Ref>(instance: TInstance, propertyName: string, operation: OPERATION, handler: Function, immediate?: boolean): () => void;
+	/**
+	 * Listen to property changes on the root state.
+	 */
+	listen<K extends PublicPropNames<TState>>(property: K, handler: PropertyChangeCallback<TState[K]>, immediate?: boolean): () => void;
+	/**
+	 * Listen to property changes on a nested instance.
+	 */
+	listen<TInstance extends Schema, K extends PublicPropNames<TInstance>>(instance: TInstance, property: K, handler: PropertyChangeCallback<TInstance[K]>, immediate?: boolean): () => void;
+	protected listenInstance<TInstance extends IRef>(instance: TInstance, propertyName: string, handler: PropertyChangeCallback<any>, immediate?: boolean): () => void;
+	/**
+	 * Listen to any property change on an instance.
+	 */
+	onChange<TInstance extends Schema>(instance: TInstance, handler: InstanceChangeCallback): () => void;
+	/**
+	 * Listen to item changes in a collection on root state.
+	 */
+	onChange<K extends CollectionPropNames<TState>>(property: K, handler: KeyValueCallback<CollectionKeyType<TState, K>, CollectionValueType<TState, K>>): () => void;
+	/**
+	 * Listen to item changes in a nested collection.
+	 */
+	onChange<TInstance extends Schema, K extends CollectionPropNames<TInstance>>(instance: TInstance, property: K, handler: KeyValueCallback<CollectionKeyType<TInstance, K>, CollectionValueType<TInstance, K>>): () => void;
+	/**
+	 * Listen to items added to a collection on root state.
+	 */
+	onAdd<K extends CollectionPropNames<TState>>(property: K, handler: ValueKeyCallback<CollectionValueType<TState, K>, CollectionKeyType<TState, K>>, immediate?: boolean): () => void;
+	/**
+	 * Listen to items added to a nested collection.
+	 */
+	onAdd<TInstance extends Schema, K extends CollectionPropNames<TInstance>>(instance: TInstance, property: K, handler: ValueKeyCallback<CollectionValueType<TInstance, K>, CollectionKeyType<TInstance, K>>, immediate?: boolean): () => void;
+	/**
+	 * Listen to items removed from a collection on root state.
+	 */
+	onRemove<K extends CollectionPropNames<TState>>(property: K, handler: ValueKeyCallback<CollectionValueType<TState, K>, CollectionKeyType<TState, K>>): () => void;
+	/**
+	 * Listen to items removed from a nested collection.
+	 */
+	onRemove<TInstance extends Schema, K extends CollectionPropNames<TInstance>>(instance: TInstance, property: K, handler: ValueKeyCallback<CollectionValueType<TInstance, K>, CollectionKeyType<TInstance, K>>): () => void;
+	/**
+	 * Bind properties from a Schema instance to a target object.
+	 * Changes will be automatically reflected on the target object.
+	 */
+	bindTo<TInstance extends Schema, TTarget>(from: TInstance, to: TTarget, properties?: string[], immediate?: boolean): () => void;
+	protected triggerChanges(allChanges: DataChange[]): void;
+}
+/**
+ * Factory class for retrieving the callbacks API.
+ */
+export declare const Callbacks: {
+	/**
+	 * Get the new callbacks standard API.
+	 *
+	 * Usage:
+	 * ```ts
+	 * const callbacks = Callbacks.get(roomOrDecoder);
+	 *
+	 * // Listen to property changes
+	 * callbacks.listen("currentTurn", (currentValue, previousValue) => { ... });
+	 *
+	 * // Listen to collection additions
+	 * callbacks.onAdd("entities", (entity, sessionId) => {
+	 *     // Nested property listening
+	 *     callbacks.listen(entity, "hp", (currentHp, previousHp) => { ... });
+	 * });
+	 *
+	 * // Listen to collection removals
+	 * callbacks.onRemove("entities", (entity, sessionId) => { ... });
+	 *
+	 * // Listen to any property change on an instance
+	 * callbacks.onChange(entity, () => { ... });
+	 *
+	 * // Bind properties to another object
+	 * callbacks.bindTo(player, playerVisual);
+	 * ```
+	 *
+	 * @param roomOrDecoder - Room or Decoder instance to get the callbacks for.
+	 * @returns the new callbacks standard API.
+	 */
+	get<T extends IRef>(roomOrDecoder: Decoder<T> | {
+		serializer: {
+			decoder: Decoder<T>;
+		};
+	} | {
+		state: T;
+		serializer: object;
+	}): StateCallbackStrategy<T>;
+	/**
+	 * Get the legacy callbacks API.
+	 *
+	 * We aim to deprecate this API on 1.0, and iterate on improving Callbacks.get() API.
+	 *
+	 * @param roomOrDecoder - Room or Decoder instance to get the legacy callbacks for.
+	 * @returns the legacy callbacks API.
+	 */
+	getLegacy<T extends Schema>(roomOrDecoder: Decoder<T> | {
+		serializer: {
+			decoder: Decoder<T>;
+		};
+	} | {
+		state: T;
+		serializer: object;
+	}): SchemaCallbackProxy<T>;
+	getRawChanges(decoder: Decoder, callback: (changes: DataChange[]) => void): void;
+};
+declare enum FLOAT32_OPTIONS {
+	NEVER = 0,
+	ALWAYS = 1,
+	DECIMAL_ROUND = 3,
+	DECIMAL_FIT = 4
+}
+interface Options {
+	useFloat32?: FLOAT32_OPTIONS;
+	useRecords?: boolean | ((value: any) => boolean);
+	structures?: {}[];
+	moreTypes?: boolean;
+	sequential?: boolean;
+	structuredClone?: boolean;
+	mapsAsObjects?: boolean;
+	variableMapSize?: boolean;
+	coercibleKeyAsNumber?: boolean;
+	copyBuffers?: boolean;
+	bundleStrings?: boolean;
+	useTimestamp32?: boolean;
+	largeBigIntToFloat?: boolean;
+	largeBigIntToString?: boolean;
+	useBigIntExtension?: boolean;
+	encodeUndefinedAsNil?: boolean;
+	maxSharedStructures?: number;
+	maxOwnStructures?: number;
+	mapAsEmptyObject?: boolean;
+	setAsEmptyObject?: boolean;
+	allowArraysInMapKeys?: boolean;
+	writeFunction?: () => any;
+	/** @deprecated use int64AsType: 'number' */
+	int64AsNumber?: boolean;
+	int64AsType?: "bigint" | "number" | "string";
+	shouldShareStructure?: (keys: string[]) => boolean;
+	getStructures?(): {}[];
+	saveStructures?(structures: {}[]): boolean | void;
+	onInvalidDate?: () => any;
+}
+type UnpackOptions = {
+	start?: number;
+	end?: number;
+	lazy?: boolean;
+} | number;
+declare class Unpackr {
+	constructor(options?: Options);
+	unpack(messagePack: Buffer | Uint8Array, options?: UnpackOptions): any;
+	decode(messagePack: Buffer | Uint8Array, options?: UnpackOptions): any;
+	unpackMultiple(messagePack: Buffer | Uint8Array): any[];
+	unpackMultiple(messagePack: Buffer | Uint8Array, forEach: (value: any, start?: number, end?: number) => any): void;
+}
+declare class Packr extends Unpackr {
+	offset: number;
+	position: number;
+	buffer: Buffer | Uint8Array;
+	pack(value: any, encodeOptions?: number): Buffer;
+	encode(value: any, encodeOptions?: number): Buffer;
+	useBuffer(buffer: Buffer | Uint8Array): void;
+	clearSharedData(): void;
+}
+interface ITransportEventMap {
+	onopen?: ((ev: any) => any) | null;
+	onmessage?: ((ev: any) => any) | null;
+	onclose?: ((ev: any) => any) | null;
+	onerror?: ((ev: any) => any) | null;
+}
+interface ITransport {
+	isOpen: boolean;
+	send(data: Buffer | Uint8Array): void;
+	sendUnreliable(data: Buffer | Uint8Array): void;
+	connect(url: string, options?: any): void;
+	close(code?: number, reason?: string): void;
+}
+declare class Connection implements ITransport {
+	#private;
+	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;
+}
+interface Serializer<State> {
+	setState(data: Uint8Array, it?: Iterator$1): void;
+	getState(): State;
+	patch(data: Uint8Array, it?: Iterator$1): void;
+	teardown(): void;
+	handshake?(bytes: Uint8Array, it?: any): void;
+}
+export declare function registerSerializer(id: string, serializer: any): void;
+type SchemaConstructor<T = Schema> = new (...args: any[]) => T;
+export declare function getStateCallbacks<T>(room: Room<any, T>): SchemaCallbackProxy<T>;
+export declare class SchemaSerializer<T extends Schema = any> implements Serializer<T> {
+	state: T;
+	decoder: Decoder<T>;
+	setState(encodedState: Uint8Array, it?: Iterator$1): void;
+	getState(): T;
+	patch(patches: Uint8Array, it?: Iterator$1): DataChange<any, string>[];
+	teardown(): void;
+	handshake(bytes: Uint8Array, it?: Iterator$1): void;
+}
+type FunctionParameters<T extends (...args: any[]) => any> = T extends (...args: infer P) => any ? P : never;
+declare class EventEmitter<CallbackSignature extends (...args: any[]) => any> {
+	handlers: Array<CallbackSignature>;
+	register(cb: CallbackSignature, once?: boolean): this;
+	invoke(...args: FunctionParameters<CallbackSignature>): void;
+	invokeAsync(...args: FunctionParameters<CallbackSignature>): Promise<any[]>;
+	remove(cb: CallbackSignature): void;
+	clear(): void;
+}
+type EventsMap = Record<string, (...args: any[]) => void>;
+interface Emitter<Events extends EventsMap> {
+	events: {
+		[K in keyof Events]?: Array<Events[K]>;
+	};
+	emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): void;
+	on<K extends keyof Events>(event: K, cb: Events[K]): () => void;
+}
+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;
+}
+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<T = any, State = InferState<T, never>> {
+	#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) => 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) => 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) => 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) => 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) => 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>) => EventEmitter<(...args: any[]) => void | Promise<any>>);
+	serializerId: string;
+	serializer: InferSerializer<State>;
+	reconnection: ReconnectionOptions;
+	protected joinedAtTime: number;
+	protected onMessageHandlers: Emitter<EventsMap>;
+	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 ExtractRoomClientMessages<NormalizeRoomType<T>>>(message: MessageType, callback: (payload: ExtractRoomClientMessages<NormalizeRoomType<T>>[MessageType]) => void): () => void;
+	onMessage<Payload = any>(type: "*", callback: (messageType: string | number, payload: Payload) => void): () => void;
+	onMessage<Payload = any>(type: [
+		keyof ExtractRoomClientMessages<NormalizeRoomType<T>>
+	] extends [
+		never
+	] ? (string | number) : never, callback: (payload: Payload) => void): () => void;
+	ping(callback: (ms: number) => void): void;
+	send<MessageType extends keyof ExtractRoomMessages<NormalizeRoomType<T>>>(messageType: MessageType, payload?: ExtractMessageType<ExtractRoomMessages<NormalizeRoomType<T>>[MessageType]>): void;
+	send<Payload = any>(messageType: [
+		keyof ExtractRoomMessages<NormalizeRoomType<T>>
+	] extends [
+		never
+	] ? (string | number) : never, payload?: Payload): void;
+	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;
+}
+type RequiredKeysOf<BaseType extends object> = Exclude<{
+	[Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
+}[keyof BaseType], undefined>;
+type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
+	/** The Standard Schema properties. */
+	readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1$1 {
+	/** The Standard Schema properties interface. */
+	interface Props<Input = unknown, Output = Input> {
+		/** The version number of the standard. */
+		readonly version: 1;
+		/** The vendor name of the schema library. */
+		readonly vendor: string;
+		/** Validates unknown input values. */
+		readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+		/** Inferred types associated with the schema. */
+		readonly types?: Types<Input, Output> | undefined;
+	}
+	/** The result interface of the validate function. */
+	type Result<Output> = SuccessResult<Output> | FailureResult;
+	/** The result interface if validation succeeds. */
+	interface SuccessResult<Output> {
+		/** The typed output value. */
+		readonly value: Output;
+		/** The non-existent issues. */
+		readonly issues?: undefined;
+	}
+	/** The result interface if validation fails. */
+	interface FailureResult {
+		/** The issues of failed validation. */
+		readonly issues: ReadonlyArray<Issue>;
+	}
+	/** The issue interface of the failure output. */
+	interface Issue {
+		/** The error message of the issue. */
+		readonly message: string;
+		/** The path of the issue, if any. */
+		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+	}
+	/** The path segment interface of the issue. */
+	interface PathSegment {
+		/** The key representing a path segment. */
+		readonly key: PropertyKey;
+	}
+	/** The Standard Schema types interface. */
+	interface Types<Input = unknown, Output = Input> {
+		/** The input type of the schema. */
+		readonly input: Input;
+		/** The output type of the schema. */
+		readonly output: Output;
+	}
+	/** Infers the input type of a Standard Schema. */
+	type InferInput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
+	/** Infers the output type of a Standard Schema. */
+	type InferOutput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+declare const statusCodes: {
+	OK: number;
+	CREATED: number;
+	ACCEPTED: number;
+	NO_CONTENT: number;
+	MULTIPLE_CHOICES: number;
+	MOVED_PERMANENTLY: number;
+	FOUND: number;
+	SEE_OTHER: number;
+	NOT_MODIFIED: number;
+	TEMPORARY_REDIRECT: number;
+	BAD_REQUEST: number;
+	UNAUTHORIZED: number;
+	PAYMENT_REQUIRED: number;
+	FORBIDDEN: number;
+	NOT_FOUND: number;
+	METHOD_NOT_ALLOWED: number;
+	NOT_ACCEPTABLE: number;
+	PROXY_AUTHENTICATION_REQUIRED: number;
+	REQUEST_TIMEOUT: number;
+	CONFLICT: number;
+	GONE: number;
+	LENGTH_REQUIRED: number;
+	PRECONDITION_FAILED: number;
+	PAYLOAD_TOO_LARGE: number;
+	URI_TOO_LONG: number;
+	UNSUPPORTED_MEDIA_TYPE: number;
+	RANGE_NOT_SATISFIABLE: number;
+	EXPECTATION_FAILED: number;
+	"I'M_A_TEAPOT": number;
+	MISDIRECTED_REQUEST: number;
+	UNPROCESSABLE_ENTITY: number;
+	LOCKED: number;
+	FAILED_DEPENDENCY: number;
+	TOO_EARLY: number;
+	UPGRADE_REQUIRED: number;
+	PRECONDITION_REQUIRED: number;
+	TOO_MANY_REQUESTS: number;
+	REQUEST_HEADER_FIELDS_TOO_LARGE: number;
+	UNAVAILABLE_FOR_LEGAL_REASONS: number;
+	INTERNAL_SERVER_ERROR: number;
+	NOT_IMPLEMENTED: number;
+	BAD_GATEWAY: number;
+	SERVICE_UNAVAILABLE: number;
+	GATEWAY_TIMEOUT: number;
+	HTTP_VERSION_NOT_SUPPORTED: number;
+	VARIANT_ALSO_NEGOTIATES: number;
+	INSUFFICIENT_STORAGE: number;
+	LOOP_DETECTED: number;
+	NOT_EXTENDED: number;
+	NETWORK_AUTHENTICATION_REQUIRED: number;
+};
+type Status = 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+declare class InternalAPIError extends Error {
+	status: keyof typeof statusCodes | Status;
+	body: ({
+		message?: string;
+		code?: string;
+		cause?: unknown;
+	} & Record<string, any>) | undefined;
+	headers: HeadersInit;
+	statusCode: number;
+	constructor(status?: keyof typeof statusCodes | Status, body?: ({
+		message?: string;
+		code?: string;
+		cause?: unknown;
+	} & Record<string, any>) | undefined, headers?: HeadersInit, statusCode?: number);
+}
+type APIError = InstanceType<typeof InternalAPIError>;
+declare const APIError: new (status?: "OK" | "CREATED" | "ACCEPTED" | "NO_CONTENT" | "MULTIPLE_CHOICES" | "MOVED_PERMANENTLY" | "FOUND" | "SEE_OTHER" | "NOT_MODIFIED" | "TEMPORARY_REDIRECT" | "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "NOT_ACCEPTABLE" | "PROXY_AUTHENTICATION_REQUIRED" | "REQUEST_TIMEOUT" | "CONFLICT" | "GONE" | "LENGTH_REQUIRED" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "URI_TOO_LONG" | "UNSUPPORTED_MEDIA_TYPE" | "RANGE_NOT_SATISFIABLE" | "EXPECTATION_FAILED" | "I'M_A_TEAPOT" | "MISDIRECTED_REQUEST" | "UNPROCESSABLE_ENTITY" | "LOCKED" | "FAILED_DEPENDENCY" | "TOO_EARLY" | "UPGRADE_REQUIRED" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "REQUEST_HEADER_FIELDS_TOO_LARGE" | "UNAVAILABLE_FOR_LEGAL_REASONS" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "HTTP_VERSION_NOT_SUPPORTED" | "VARIANT_ALSO_NEGOTIATES" | "INSUFFICIENT_STORAGE" | "LOOP_DETECTED" | "NOT_EXTENDED" | "NETWORK_AUTHENTICATION_REQUIRED" | Status | undefined, body?: ({
+	message?: string;
+	code?: string;
+	cause?: unknown;
+} & Record<string, any>) | undefined, headers?: HeadersInit | undefined, statusCode?: number | undefined) => InternalAPIError & {
+	errorStack: string | undefined;
+};
+type OpenAPISchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
+interface OpenAPIParameter {
+	in: "query" | "path" | "header" | "cookie";
+	name?: string;
+	description?: string;
+	required?: boolean;
+	schema?: {
+		type: OpenAPISchemaType;
+		format?: string;
+		items?: {
+			type: OpenAPISchemaType;
+		};
+		enum?: string[];
+		minLength?: number;
+		description?: string;
+		default?: string;
+		example?: string;
+	};
+}
+interface EndpointBaseOptions {
+	/**
+	 * Query Schema
+	 */
+	query?: StandardSchemaV1$1;
+	/**
+	 * Error Schema
+	 */
+	error?: StandardSchemaV1$1;
+	/**
+	 * If true headers will be required to be passed in the context
+	 */
+	requireHeaders?: boolean;
+	/**
+	 * If true request object will be required
+	 */
+	requireRequest?: boolean;
+	/**
+	 * Clone the request object from the router
+	 */
+	cloneRequest?: boolean;
+	/**
+	 * If true the body will be undefined
+	 */
+	disableBody?: boolean;
+	/**
+	 * Endpoint metadata
+	 */
+	metadata?: {
+		/**
+		 * Open API definition
+		 */
+		openapi?: {
+			summary?: string;
+			description?: string;
+			tags?: string[];
+			operationId?: string;
+			parameters?: OpenAPIParameter[];
+			requestBody?: {
+				content: {
+					"application/json": {
+						schema: {
+							type?: OpenAPISchemaType;
+							properties?: Record<string, any>;
+							required?: string[];
+							$ref?: string;
+						};
+					};
+				};
+			};
+			responses?: {
+				[status: string]: {
+					description: string;
+					content?: {
+						"application/json"?: {
+							schema: {
+								type?: OpenAPISchemaType;
+								properties?: Record<string, any>;
+								required?: string[];
+								$ref?: string;
+							};
+						};
+						"text/plain"?: {
+							schema?: {
+								type?: OpenAPISchemaType;
+								properties?: Record<string, any>;
+								required?: string[];
+								$ref?: string;
+							};
+						};
+						"text/html"?: {
+							schema?: {
+								type?: OpenAPISchemaType;
+								properties?: Record<string, any>;
+								required?: string[];
+								$ref?: string;
+							};
+						};
+					};
+				};
+			};
+		};
+		/**
+		 * Infer body and query type from ts interface
+		 *
+		 * useful for generic and dynamic types
+		 *
+		 * @example
+		 * ```ts
+		 * const endpoint = createEndpoint("/path", {
+		 * 		method: "POST",
+		 * 		body: z.record(z.string()),
+		 * 		$Infer: {
+		 * 			body: {} as {
+		 * 				type: InferTypeFromOptions<Option> // custom type inference
+		 * 			}
+		 * 		}
+		 * 	}, async(ctx)=>{
+		 * 		const body = ctx.body
+		 * 	})
+		 * ```
+		 */
+		$Infer?: {
+			/**
+			 * Body
+			 */
+			body?: any;
+			/**
+			 * Query
+			 */
+			query?: Record<string, any>;
+		};
+		/**
+		 * If enabled, endpoint won't be exposed over a router
+		 * @deprecated Use path-less endpoints instead
+		 */
+		SERVER_ONLY?: boolean;
+		/**
+		 * If enabled, endpoint won't be exposed as an action to the client
+		 * @deprecated Use path-less endpoints instead
+		 */
+		isAction?: boolean;
+		/**
+		 * Defines the places where the endpoint will be available
+		 *
+		 * Possible options:
+		 * - `rpc` - the endpoint is exposed to the router, can be invoked directly and is available to the client
+		 * - `server` - the endpoint is exposed to the router, can be invoked directly, but is not available to the client
+		 * - `http` - the endpoint is only exposed to the router
+		 * @default "rpc"
+		 */
+		scope?: "rpc" | "server" | "http";
+		/**
+		 * List of allowed media types (MIME types) for the endpoint
+		 *
+		 * if provided, only the media types in the list will be allowed to be passed in the body
+		 *
+		 * @example
+		 * ```ts
+		 * const endpoint = createEndpoint("/path", {
+		 * 		method: "POST",
+		 * 		allowedMediaTypes: ["application/json", "application/x-www-form-urlencoded"],
+		 * 	}, async(ctx)=>{
+		 * 		const body = ctx.body
+		 * 	})
+		 * ```
+		 */
+		allowedMediaTypes?: string[];
+		/**
+		 * Extra metadata
+		 */
+		[key: string]: any;
+	};
+	/**
+	 * List of middlewares to use
+	 */
+	use?: Middleware[];
+	/**
+	 * A callback to run before any API error is throw or returned
+	 *
+	 * @param e - The API error
+	 * @returns - The response to return
+	 */
+	onAPIError?: (e: APIError) => void | Promise<void>;
+	/**
+	 * A callback to run before a validation error is thrown
+	 * You can customize the validation error message by throwing your own APIError
+	 */
+	onValidationError?: ({ issues, message }: {
+		message: string;
+		issues: readonly StandardSchemaV1$1.Issue[];
+	}) => void | Promise<void>;
+}
+type EndpointBodyMethodOptions = {
+	/**
+	 * Request Method
+	 */
+	method: "POST" | "PUT" | "DELETE" | "PATCH" | ("POST" | "PUT" | "DELETE" | "PATCH")[];
+	/**
+	 * Body Schema
+	 */
+	body?: StandardSchemaV1$1;
+} | {
+	/**
+	 * Request Method
+	 */
+	method: "GET" | "HEAD" | ("GET" | "HEAD")[];
+	/**
+	 * Body Schema
+	 */
+	body?: never;
+} | {
+	/**
+	 * Request Method
+	 */
+	method: "*";
+	/**
+	 * Body Schema
+	 */
+	body?: StandardSchemaV1$1;
+} | {
+	/**
+	 * Request Method
+	 */
+	method: ("POST" | "PUT" | "DELETE" | "PATCH" | "GET" | "HEAD")[];
+	/**
+	 * Body Schema
+	 */
+	body?: StandardSchemaV1$1;
+};
+type EndpointOptions = EndpointBaseOptions & EndpointBodyMethodOptions;
+type Endpoint<Path extends string = string, Options extends EndpointOptions = EndpointOptions, Handler extends (inputCtx: any) => Promise<any> = (inputCtx: any) => Promise<any>> = Handler & {
+	options: Options;
+	path: Path;
+};
+interface MiddlewareOptions extends Omit<EndpointOptions, "method"> {
+}
+type Middleware<Options extends MiddlewareOptions = MiddlewareOptions, Handler extends (inputCtx: any) => Promise<any> = any> = Handler & {
+	options: Options;
+};
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+interface RouterConfig {
+	throwError?: boolean;
+	onError?: (e: unknown) => void | Promise<void> | Response | Promise<Response>;
+	basePath?: string;
+	routerMiddleware?: Array<{
+		path: string;
+		middleware: Middleware;
+	}>;
+	/**
+	 * additional Context that needs to passed to endpoints
+	 *
+	 * this will be available on `ctx.context` on endpoints
+	 */
+	routerContext?: Record<string, any>;
+	/**
+	 * A callback to run before any response
+	 */
+	onResponse?: (res: Response) => any | Promise<any>;
+	/**
+	 * A callback to run before any request
+	 */
+	onRequest?: (req: Request) => any | Promise<any>;
+	/**
+	 * List of allowed media types (MIME types) for the router
+	 *
+	 * if provided, only the media types in the list will be allowed to be passed in the body.
+	 *
+	 * If an endpoint has allowed media types, it will override the router's allowed media types.
+	 *
+	 * @example
+	 * ```ts
+	 * const router = createRouter({
+	 * 		allowedMediaTypes: ["application/json", "application/x-www-form-urlencoded"],
+	 * 	})
+	 */
+	allowedMediaTypes?: string[];
+	/**
+	 * Skip trailing slashes
+	 *
+	 * @default false
+	 */
+	skipTrailingSlashes?: boolean;
+	/**
+	 * Open API route configuration
+	 */
+	openapi?: {
+		/**
+		 * Disable openapi route
+		 *
+		 * @default false
+		 */
+		disabled?: boolean;
+		/**
+		 * A path to display open api using scalar
+		 *
+		 * @default "/api/reference"
+		 */
+		path?: string;
+		/**
+		 * Scalar Configuration
+		 */
+		scalar?: {
+			/**
+			 * Title
+			 * @default "Open API Reference"
+			 */
+			title?: string;
+			/**
+			 * Description
+			 *
+			 * @default "Better Call Open API Reference"
+			 */
+			description?: string;
+			/**
+			 * Logo URL
+			 */
+			logo?: string;
+			/**
+			 * Scalar theme
+			 * @default "saturn"
+			 */
+			theme?: string;
+		};
+	};
+}
+declare const createRouter: <E extends Record<string, Endpoint>, Config extends RouterConfig>(endpoints: E, config?: Config) => {
+	handler: (request: Request) => Promise<Response>;
+	endpoints: E;
+	/**
+	 * Add a new endpoint to the router.
+	 * This is useful if you want to add an endpoint to the router after it has been created.
+	 */
+	addEndpoint: (endpoint: Endpoint) => void;
+	/**
+	 * Find a route in the router.
+	 * @param method - The HTTP method of the route.
+	 * @param path - The path of the route.
+	 * @returns The route data and parameters.
+	 */
+	findRoute: (method: string, path: string) => {
+		data: Endpoint & {
+			path: string;
+		};
+		params: Record<string, string>;
+	};
+	/**
+	 * Extend the router with new endpoints
+	 * @param newEndpoints new endpoints to extend the router with
+	 * @returns new router with additional endpoints
+	 */
+	extend: <NE extends Record<string, Endpoint>>(newEndpoints: NE) => {
+		handler: (request: Request) => Promise<Response>;
+		endpoints: E & NE;
+		/**
+		 * Add a new endpoint to the router.
+		 * This is useful if you want to add an endpoint to the router after it has been created.
+		 */
+		addEndpoint: (endpoint: Endpoint) => void;
+		/**
+		 * Find a route in the router.
+		 * @param method - The HTTP method of the route.
+		 * @param path - The path of the route.
+		 * @returns The route data and parameters.
+		 */
+		findRoute: (method: string, path: string) => {
+			data: ((inputCtx: any) => Promise<any>) & {
+				options: EndpointOptions;
+				path: string;
+			} & {
+				path: string;
+			};
+			params: Record<string, string>;
+		};
+		extend: <NE_1 extends Record<string, Endpoint>>(newEndpoints: NE_1) => {
+			handler: (request: Request) => Promise<Response>;
+			endpoints: E & NE & NE_1;
+			/**
+			 * Add a new endpoint to the router.
+			 * This is useful if you want to add an endpoint to the router after it has been created.
+			 */
+			addEndpoint: (endpoint: Endpoint) => void;
+			/**
+			 * Find a route in the router.
+			 * @param method - The HTTP method of the route.
+			 * @param path - The path of the route.
+			 * @returns The route data and parameters.
+			 */
+			findRoute: (method: string, path: string) => {
+				data: ((inputCtx: any) => Promise<any>) & {
+					options: EndpointOptions;
+					path: string;
+				} & {
+					path: string;
+				};
+				params: Record<string, string>;
+			};
+			extend: <NE_2 extends Record<string, Endpoint>>(newEndpoints: NE_2) => {
+				handler: (request: Request) => Promise<Response>;
+				endpoints: E & NE & NE_1 & NE_2;
+				/**
+				 * Add a new endpoint to the router.
+				 * This is useful if you want to add an endpoint to the router after it has been created.
+				 */
+				addEndpoint: (endpoint: Endpoint) => void;
+				/**
+				 * Find a route in the router.
+				 * @param method - The HTTP method of the route.
+				 * @param path - The path of the route.
+				 * @returns The route data and parameters.
+				 */
+				findRoute: (method: string, path: string) => {
+					data: ((inputCtx: any) => Promise<any>) & {
+						options: EndpointOptions;
+						path: string;
+					} & {
+						path: string;
+					};
+					params: Record<string, string>;
+				};
+				extend: <NE_3 extends Record<string, Endpoint>>(newEndpoints: NE_3) => {
+					handler: (request: Request) => Promise<Response>;
+					endpoints: E & NE & NE_1 & NE_2 & NE_3;
+					/**
+					 * Add a new endpoint to the router.
+					 * This is useful if you want to add an endpoint to the router after it has been created.
+					 */
+					addEndpoint: (endpoint: Endpoint) => void;
+					/**
+					 * Find a route in the router.
+					 * @param method - The HTTP method of the route.
+					 * @param path - The path of the route.
+					 * @returns The route data and parameters.
+					 */
+					findRoute: (method: string, path: string) => {
+						data: ((inputCtx: any) => Promise<any>) & {
+							options: EndpointOptions;
+							path: string;
+						} & {
+							path: string;
+						};
+						params: Record<string, string>;
+					};
+					extend: <NE_4 extends Record<string, Endpoint>>(newEndpoints: NE_4) => {
+						handler: (request: Request) => Promise<Response>;
+						endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4;
+						/**
+						 * Add a new endpoint to the router.
+						 * This is useful if you want to add an endpoint to the router after it has been created.
+						 */
+						addEndpoint: (endpoint: Endpoint) => void;
+						/**
+						 * Find a route in the router.
+						 * @param method - The HTTP method of the route.
+						 * @param path - The path of the route.
+						 * @returns The route data and parameters.
+						 */
+						findRoute: (method: string, path: string) => {
+							data: ((inputCtx: any) => Promise<any>) & {
+								options: EndpointOptions;
+								path: string;
+							} & {
+								path: string;
+							};
+							params: Record<string, string>;
+						};
+						extend: <NE_5 extends Record<string, Endpoint>>(newEndpoints: NE_5) => {
+							handler: (request: Request) => Promise<Response>;
+							endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5;
+							/**
+							 * Add a new endpoint to the router.
+							 * This is useful if you want to add an endpoint to the router after it has been created.
+							 */
+							addEndpoint: (endpoint: Endpoint) => void;
+							/**
+							 * Find a route in the router.
+							 * @param method - The HTTP method of the route.
+							 * @param path - The path of the route.
+							 * @returns The route data and parameters.
+							 */
+							findRoute: (method: string, path: string) => {
+								data: ((inputCtx: any) => Promise<any>) & {
+									options: EndpointOptions;
+									path: string;
+								} & {
+									path: string;
+								};
+								params: Record<string, string>;
+							};
+							extend: <NE_6 extends Record<string, Endpoint>>(newEndpoints: NE_6) => {
+								handler: (request: Request) => Promise<Response>;
+								endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6;
+								/**
+								 * Add a new endpoint to the router.
+								 * This is useful if you want to add an endpoint to the router after it has been created.
+								 */
+								addEndpoint: (endpoint: Endpoint) => void;
+								/**
+								 * Find a route in the router.
+								 * @param method - The HTTP method of the route.
+								 * @param path - The path of the route.
+								 * @returns The route data and parameters.
+								 */
+								findRoute: (method: string, path: string) => {
+									data: ((inputCtx: any) => Promise<any>) & {
+										options: EndpointOptions;
+										path: string;
+									} & {
+										path: string;
+									};
+									params: Record<string, string>;
+								};
+								extend: <NE_7 extends Record<string, Endpoint>>(newEndpoints: NE_7) => {
+									handler: (request: Request) => Promise<Response>;
+									endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7;
+									/**
+									 * Add a new endpoint to the router.
+									 * This is useful if you want to add an endpoint to the router after it has been created.
+									 */
+									addEndpoint: (endpoint: Endpoint) => void;
+									/**
+									 * Find a route in the router.
+									 * @param method - The HTTP method of the route.
+									 * @param path - The path of the route.
+									 * @returns The route data and parameters.
+									 */
+									findRoute: (method: string, path: string) => {
+										data: ((inputCtx: any) => Promise<any>) & {
+											options: EndpointOptions;
+											path: string;
+										} & {
+											path: string;
+										};
+										params: Record<string, string>;
+									};
+									extend: <NE_8 extends Record<string, Endpoint>>(newEndpoints: NE_8) => {
+										handler: (request: Request) => Promise<Response>;
+										endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8;
+										/**
+										 * Add a new endpoint to the router.
+										 * This is useful if you want to add an endpoint to the router after it has been created.
+										 */
+										addEndpoint: (endpoint: Endpoint) => void;
+										/**
+										 * Find a route in the router.
+										 * @param method - The HTTP method of the route.
+										 * @param path - The path of the route.
+										 * @returns The route data and parameters.
+										 */
+										findRoute: (method: string, path: string) => {
+											data: ((inputCtx: any) => Promise<any>) & {
+												options: EndpointOptions;
+												path: string;
+											} & {
+												path: string;
+											};
+											params: Record<string, string>;
+										};
+										extend: <NE_9 extends Record<string, Endpoint>>(newEndpoints: NE_9) => {
+											handler: (request: Request) => Promise<Response>;
+											endpoints: E & NE & NE_1 & NE_2 & NE_3 & NE_4 & NE_5 & NE_6 & NE_7 & NE_8 & NE_9;
+											/**
+											 * Add a new endpoint to the router.
+											 * This is useful if you want to add an endpoint to the router after it has been created.
+											 */
+											addEndpoint: (endpoint: Endpoint) => void;
+											/**
+											 * Find a route in the router.
+											 * @param method - The HTTP method of the route.
+											 * @param path - The path of the route.
+											 * @returns The route data and parameters.
+											 */
+											findRoute: (method: string, path: string) => {
+												data: ((inputCtx: any) => Promise<any>) & {
+													options: EndpointOptions;
+													path: string;
+												} & {
+													path: string;
+												};
+												params: Record<string, string>;
+											};
+											extend: <NE_10 extends Record<string, Endpoint>>(newEndpoints: NE_10) => any;
+										};
+									};
+								};
+							};
+						};
+					};
+				};
+			};
+		};
+	};
+};
+type Router = ReturnType<typeof createRouter>;
+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;
+} : {} : {} : {};
+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 FetchResponse<T> = {
+	raw: Response;
+	data: T;
+	headers: Headers;
+	status: number;
+	statusText: string;
+};
+type InferredAPI<R> = R extends {
+	endpoints: Record<string, Endpoint>;
+} ? WithoutServerOnly<R["endpoints"]> : WithoutServerOnly<R & Record<string, Endpoint>>;
+type InferReturnType<R, OPT, K extends keyof OPT> = IsAnyOrAnyIndexed<R> extends true ? any : Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>;
+declare class HTTP<R extends Router | Router["endpoints"]> {
+	authToken: string | undefined;
+	options: FetchRequestOptions;
+	private sdk;
+	del: {
+		<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>> = UnionToIntersection<MethodOptions<API, "DELETE">> extends infer T ? {
+			[K_1 in keyof T]: T[K_1];
+		} : never, 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<InferReturnType<R, OPT, K>>>;
+		<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>> = UnionToIntersection<MethodOptions<API, "DELETE">> extends infer T ? {
+			[K_1 in keyof T]: T[K_1];
+		} : never, 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<InferReturnType<R, OPT, K>>>;
+	};
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	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<InferReturnType<R, OPT, K>>>;
+	protected executeRequest<M extends HTTPMethod>(method: M, path: any, requestOptions?: any): Promise<any>;
+}
+export interface AuthSettings {
+	path: string;
+	key: string;
+}
+export interface PopupSettings {
+	prefix: string;
+	width: number;
+	height: number;
+}
+/**
+ * Response from getUserData()
+ */
+export interface UserDataResponse<UserData = any> {
+	user: UserData;
+}
+/**
+ * Response from authentication methods (login, register, anonymous, OAuth)
+ */
+export interface AuthResponse<UserData = any> {
+	user: UserData;
+	token: string;
+}
+/**
+ * Response from sendPasswordResetEmail()
+ */
+export type ForgotPasswordResponse = boolean | unknown;
+/**
+ * @deprecated Use AuthResponse instead
+ */
+export type AuthData<UserData = any> = AuthResponse<UserData>;
+export declare class Auth<UserData = any> {
+	#private;
+	settings: AuthSettings;
+	protected http: HTTP<any>;
+	constructor(http: HTTP<any>);
+	set token(token: string);
+	get token(): string | undefined;
+	onChange<U = UserData>(callback: (response: AuthResponse<U | null>) => void): () => void;
+	getUserData<U = UserData>(): Promise<UserDataResponse<U>>;
+	registerWithEmailAndPassword<U = UserData>(email: string, password: string, options?: any): Promise<AuthResponse<U>>;
+	signInWithEmailAndPassword<U = UserData>(email: string, password: string): Promise<AuthResponse<U>>;
+	signInAnonymously<U = UserData>(options?: any): Promise<AuthResponse<U>>;
+	sendPasswordResetEmail(email: string): Promise<ForgotPasswordResponse>;
+	signInWithProvider<U = UserData>(providerName: string, settings?: Partial<PopupSettings>): Promise<AuthResponse<U>>;
+	signOut(): Promise<void>;
+	private emitChange;
+}
+export type JoinOptions = any;
+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";
+}
+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, UserData = 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<UserData>;
+	/**
+	 * 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, UserData = any>(endpoints: Array<string | EndpointSettings>, options?: ClientOptions, latencyOptions?: LatencyOptions): Promise<ColyseusSDK<ServerType, UserData>>;
+	joinOrCreate<R extends keyof ServerType["~rooms"], State = InferState<ServerType["~rooms"][R]["~room"], never>>(roomName: R, options?: Parameters<ServerType["~rooms"][R]["~room"]["onJoin"]>[1], rootSchema?: SchemaConstructor<State>): Promise<Room<ServerType["~rooms"][R]["~room"], State>>;
+	joinOrCreate<RoomType extends ServerRoomLike>(roomName: string, options?: Parameters<NonNullable<RoomType["onJoin"]>>[1], rootSchema?: SchemaConstructor<RoomType["state"]>): Promise<Room<RoomType, RoomType["state"]>>;
+	joinOrCreate<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+	create<R extends keyof ServerType["~rooms"], State = InferState<ServerType["~rooms"][R]["~room"], never>>(roomName: R, options?: Parameters<ServerType["~rooms"][R]["~room"]["onJoin"]>[1], rootSchema?: SchemaConstructor<State>): Promise<Room<ServerType["~rooms"][R]["~room"], State>>;
+	create<RoomType extends ServerRoomLike>(roomName: string, options?: Parameters<NonNullable<RoomType["onJoin"]>>[1], rootSchema?: SchemaConstructor<RoomType["state"]>): Promise<Room<RoomType, RoomType["state"]>>;
+	create<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+	join<R extends keyof ServerType["~rooms"], State = InferState<ServerType["~rooms"][R]["~room"], never>>(roomName: R, options?: Parameters<ServerType["~rooms"][R]["~room"]["onJoin"]>[1], rootSchema?: SchemaConstructor<State>): Promise<Room<ServerType["~rooms"][R]["~room"], State>>;
+	join<RoomType extends ServerRoomLike>(roomName: string, options?: Parameters<NonNullable<RoomType["onJoin"]>>[1], rootSchema?: SchemaConstructor<RoomType["state"]>): Promise<Room<RoomType, RoomType["state"]>>;
+	join<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+	joinById<R extends keyof ServerType["~rooms"], State = InferState<ServerType["~rooms"][R]["~room"], never>>(roomName: R, options?: Parameters<ServerType["~rooms"][R]["~room"]["onJoin"]>[1], rootSchema?: SchemaConstructor<State>): Promise<Room<ServerType["~rooms"][R]["~room"], State>>;
+	joinById<RoomType extends ServerRoomLike>(roomId: string, options?: Parameters<NonNullable<RoomType["onJoin"]>>[1], rootSchema?: SchemaConstructor<RoomType["state"]>): Promise<Room<RoomType, RoomType["state"]>>;
+	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 ServerRoomLike>(reconnectionToken: string, rootSchema?: SchemaConstructor<RoomType["state"]>): Promise<Room<RoomType, RoomType["state"]>>;
+	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<ServerType extends SDKTypes = any, UserData = any> = InstanceType<typeof ColyseusSDK<ServerType, UserData>>;
+export declare class ServerError<DATA = any> extends Error {
+	code: number;
+	headers?: Headers;
+	status?: number;
+	response?: Response;
+	data?: DATA;
+	constructor(code: number, message: string, opts?: {
+		headers?: Headers;
+		status?: number;
+		response?: Response;
+		data?: any;
+	});
+}
+export declare class AbortError extends Error {
+	constructor(message: string);
+}
+export declare class MatchMakeError extends Error {
+	code: number;
+	constructor(message: string, code: number);
+}
+declare class Delayed {
+	active: boolean;
+	paused: boolean;
+	time: number;
+	elapsedTime: number;
+	protected handler: Function;
+	protected args: any;
+	protected type: number;
+	constructor(handler: Function, args: any, time: number, type: number);
+	tick(deltaTime: number): void;
+	execute(): void;
+	reset(): void;
+	pause(): void;
+	resume(): void;
+	clear(): void;
+}
+declare class Clock {
+	running: boolean;
+	deltaTime: number;
+	currentTime: number;
+	elapsedTime: number;
+	protected now: Function;
+	protected _interval: any;
+	constructor(useInterval?: boolean);
+	start(useInterval?: boolean): void;
+	stop(): void;
+	tick(newTime?: any): void;
+}
+declare class ClockTimer extends Clock {
+	/**
+	 * An array of all the scheduled timeouts and intervals.
+	 * @private For compatibility it's public but avoid modifying it directly.
+	 */
+	delayed: Delayed[];
+	constructor(autoStart?: boolean);
+	/**
+	 * Re-evaluate all the scheduled timeouts and intervals and execute appropriate handlers.
+	 * Use this in your own context or not if your passed `autoStart` as `true` in the constructor.
+	 */
+	tick(): void;
+	/**
+	 * Schedule a function to be called every `time` milliseconds.
+	 * This `time` minimum value will be tied to the `tick` method of the clock. This means if you use the default `autoStart` value from the constructor, the minimum value will be 16ms. Otherwise it will depend on your `tick` method call.
+	 *
+	 * Returns a {@link Delayed} object that can be used to clear the timeout or play around with it.
+	 */
+	setInterval(handler: Function, time: number, ...args: any[]): Delayed;
+	/**
+	 * Schedule a function to be called after a delay.
+	 *
+	 * This `time` minimum value will be tied to the `tick` method of the clock. This means if you use the default `autoStart` value from the constructor, the minimum value will be 16ms. Otherwise it will depend on your `tick` method call.
+	 *
+	 * Returns a {@link Delayed} object that can be used to clear the timeout or play around with it.
+	 */
+	setTimeout(handler: Function, time: number, ...args: any[]): Delayed;
+	/**
+	 * A promise that schedule a timeout that will resolves after the given time.
+	 *
+	 * If the {@link Delayed} instance is cleared before the time, the promise will be rejected. This happens when the {@link ClockTimer.clear} method is called.
+	 *
+	 * For the sake of simplicity of this API, you can only cancel a timeout scheduled with this method with {@link ClockTimer.clear} method (which clears all scheduled timeouts and intervals).
+	 * If you need fine-tuned control over the timeout, use the {@link ClockTimer.setTimeout} method instead.
+	 *
+	 * @example **Inside an async function**
+	 * ```typescript
+	 * const timer = new Clock(true);
+	 * await timer.duration(1000);
+	 * console.log("1 second later");
+	 * ```
+	 *
+	 * @example **Using the promise**
+	 * ```typescript
+	 * const timer = new Clock(true);
+	 * timer.duration(1000).then(() => console.log("1 second later"));
+	 * ```
+	 *
+	 * @example **Using the promise with error**
+	 * ```typescript
+	 * const timer = new Clock(true);
+	 * timer.duration(1000).then(() => console.log("1 second later")).catch(() => console.log("Timer cleared"));
+	 * timer.clear();
+	 * ```
+	 *
+	 *
+	 * @param ms the duration in milliseconds in which the promise will be resolved
+	 */
+	duration(ms: number): Promise<void>;
+	/**
+	 * Delete any scheduled timeout or interval. That will never be executed.
+	 *
+	 * If some of the timeouts/intervals are already executed, they will be removed from the list and callback will be garbage collected.
+	 * For timeout created with {@link ClockTimer.duration}, the promise will be rejected and therefore the unused resolving callback will be garbage collected.
+	 */
+	clear(): void;
+}
+interface EventEmitterOptions {
+	/**
+	 * Enables automatic capturing of promise rejection.
+	 */
+	captureRejections?: boolean | undefined;
+}
+interface StaticEventEmitterOptions {
+	/**
+	 * Can be used to cancel awaiting events.
+	 */
+	signal?: AbortSignal | undefined;
+}
+interface StaticEventEmitterIteratorOptions extends StaticEventEmitterOptions {
+	/**
+	 * Names of events that will end the iteration.
+	 */
+	close?: string[] | undefined;
+	/**
+	 * The high watermark. The emitter is paused every time the size of events being buffered is higher than it.
+	 * Supported only on emitters implementing `pause()` and `resume()` methods.
+	 * @default Number.MAX_SAFE_INTEGER
+	 */
+	highWaterMark?: number | undefined;
+	/**
+	 * The low watermark. The emitter is resumed every time the size of events being buffered is lower than it.
+	 * Supported only on emitters implementing `pause()` and `resume()` methods.
+	 * @default 1
+	 */
+	lowWaterMark?: number | undefined;
+}
+interface EventEmitter$1<T extends EventMap<T> = DefaultEventMap> extends NodeJS.EventEmitter<T> {
+}
+type EventMap<T> = Record<keyof T, any[]> | DefaultEventMap;
+type DefaultEventMap = [
+	never
+];
+type AnyRest = [
+	...args: any[]
+];
+type Args<K, T> = T extends DefaultEventMap ? AnyRest : (K extends keyof T ? T[K] : never);
+type Key<K, T> = T extends DefaultEventMap ? string | symbol : K | keyof T;
+declare class EventEmitter$1<T extends EventMap<T> = DefaultEventMap> {
+	constructor(options?: EventEmitterOptions);
+	[EventEmitter$1.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;
+	/**
+	 * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
+	 * event or that is rejected if the `EventEmitter` emits `'error'` while waiting.
+	 * The `Promise` will resolve with an array of all the arguments emitted to the
+	 * given event.
+	 *
+	 * This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
+	 * semantics and does not listen to the `'error'` event.
+	 *
+	 * ```js
+	 * import { once, EventEmitter } from 'node:events';
+	 * import process from 'node:process';
+	 *
+	 * const ee = new EventEmitter();
+	 *
+	 * process.nextTick(() => {
+	 *   ee.emit('myevent', 42);
+	 * });
+	 *
+	 * const [value] = await once(ee, 'myevent');
+	 * console.log(value);
+	 *
+	 * const err = new Error('kaboom');
+	 * process.nextTick(() => {
+	 *   ee.emit('error', err);
+	 * });
+	 *
+	 * try {
+	 *   await once(ee, 'myevent');
+	 * } catch (err) {
+	 *   console.error('error happened', err);
+	 * }
+	 * ```
+	 *
+	 * The special handling of the `'error'` event is only used when `events.once()` is used to wait for another event. If `events.once()` is used to wait for the
+	 * '`error'` event itself, then it is treated as any other kind of event without
+	 * special handling:
+	 *
+	 * ```js
+	 * import { EventEmitter, once } from 'node:events';
+	 *
+	 * const ee = new EventEmitter();
+	 *
+	 * once(ee, 'error')
+	 *   .then(([err]) => console.log('ok', err.message))
+	 *   .catch((err) => console.error('error', err.message));
+	 *
+	 * ee.emit('error', new Error('boom'));
+	 *
+	 * // Prints: ok boom
+	 * ```
+	 *
+	 * An `AbortSignal` can be used to cancel waiting for the event:
+	 *
+	 * ```js
+	 * import { EventEmitter, once } from 'node:events';
+	 *
+	 * const ee = new EventEmitter();
+	 * const ac = new AbortController();
+	 *
+	 * async function foo(emitter, event, signal) {
+	 *   try {
+	 *     await once(emitter, event, { signal });
+	 *     console.log('event emitted!');
+	 *   } catch (error) {
+	 *     if (error.name === 'AbortError') {
+	 *       console.error('Waiting for the event was canceled!');
+	 *     } else {
+	 *       console.error('There was an error', error.message);
+	 *     }
+	 *   }
+	 * }
+	 *
+	 * foo(ee, 'foo', ac.signal);
+	 * ac.abort(); // Abort waiting for the event
+	 * ee.emit('foo'); // Prints: Waiting for the event was canceled!
+	 * ```
+	 * @since v11.13.0, v10.16.0
+	 */
+	static once(emitter: NodeJS.EventEmitter, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>;
+	static once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
+	/**
+	 * ```js
+	 * import { on, EventEmitter } from 'node:events';
+	 * import process from 'node:process';
+	 *
+	 * const ee = new EventEmitter();
+	 *
+	 * // Emit later on
+	 * process.nextTick(() => {
+	 *   ee.emit('foo', 'bar');
+	 *   ee.emit('foo', 42);
+	 * });
+	 *
+	 * for await (const event of on(ee, 'foo')) {
+	 *   // The execution of this inner block is synchronous and it
+	 *   // processes one event at a time (even with await). Do not use
+	 *   // if concurrent execution is required.
+	 *   console.log(event); // prints ['bar'] [42]
+	 * }
+	 * // Unreachable here
+	 * ```
+	 *
+	 * Returns an `AsyncIterator` that iterates `eventName` events. It will throw
+	 * if the `EventEmitter` emits `'error'`. It removes all listeners when
+	 * exiting the loop. The `value` returned by each iteration is an array
+	 * composed of the emitted event arguments.
+	 *
+	 * An `AbortSignal` can be used to cancel waiting on events:
+	 *
+	 * ```js
+	 * import { on, EventEmitter } from 'node:events';
+	 * import process from 'node:process';
+	 *
+	 * const ac = new AbortController();
+	 *
+	 * (async () => {
+	 *   const ee = new EventEmitter();
+	 *
+	 *   // Emit later on
+	 *   process.nextTick(() => {
+	 *     ee.emit('foo', 'bar');
+	 *     ee.emit('foo', 42);
+	 *   });
+	 *
+	 *   for await (const event of on(ee, 'foo', { signal: ac.signal })) {
+	 *     // The execution of this inner block is synchronous and it
+	 *     // processes one event at a time (even with await). Do not use
+	 *     // if concurrent execution is required.
+	 *     console.log(event); // prints ['bar'] [42]
+	 *   }
+	 *   // Unreachable here
+	 * })();
+	 *
+	 * process.nextTick(() => ac.abort());
+	 * ```
+	 *
+	 * Use the `close` option to specify an array of event names that will end the iteration:
+	 *
+	 * ```js
+	 * import { on, EventEmitter } from 'node:events';
+	 * import process from 'node:process';
+	 *
+	 * const ee = new EventEmitter();
+	 *
+	 * // Emit later on
+	 * process.nextTick(() => {
+	 *   ee.emit('foo', 'bar');
+	 *   ee.emit('foo', 42);
+	 *   ee.emit('close');
+	 * });
+	 *
+	 * for await (const event of on(ee, 'foo', { close: ['close'] })) {
+	 *   console.log(event); // prints ['bar'] [42]
+	 * }
+	 * // the loop will exit after 'close' is emitted
+	 * console.log('done'); // prints 'done'
+	 * ```
+	 * @since v13.6.0, v12.16.0
+	 * @return An `AsyncIterator` that iterates `eventName` events emitted by the `emitter`
+	 */
+	static on(emitter: NodeJS.EventEmitter, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): NodeJS.AsyncIterator<any[]>;
+	static on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): NodeJS.AsyncIterator<any[]>;
+	/**
+	 * A class method that returns the number of listeners for the given `eventName` registered on the given `emitter`.
+	 *
+	 * ```js
+	 * import { EventEmitter, listenerCount } from 'node:events';
+	 *
+	 * const myEmitter = new EventEmitter();
+	 * myEmitter.on('event', () => {});
+	 * myEmitter.on('event', () => {});
+	 * console.log(listenerCount(myEmitter, 'event'));
+	 * // Prints: 2
+	 * ```
+	 * @since v0.9.12
+	 * @deprecated Since v3.2.0 - Use `listenerCount` instead.
+	 * @param emitter The emitter to query
+	 * @param eventName The event name
+	 */
+	static listenerCount(emitter: NodeJS.EventEmitter, eventName: string | symbol): number;
+	/**
+	 * Returns a copy of the array of listeners for the event named `eventName`.
+	 *
+	 * For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
+	 * the emitter.
+	 *
+	 * For `EventTarget`s this is the only way to get the event listeners for the
+	 * event target. This is useful for debugging and diagnostic purposes.
+	 *
+	 * ```js
+	 * import { getEventListeners, EventEmitter } from 'node:events';
+	 *
+	 * {
+	 *   const ee = new EventEmitter();
+	 *   const listener = () => console.log('Events are fun');
+	 *   ee.on('foo', listener);
+	 *   console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
+	 * }
+	 * {
+	 *   const et = new EventTarget();
+	 *   const listener = () => console.log('Events are fun');
+	 *   et.addEventListener('foo', listener);
+	 *   console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
+	 * }
+	 * ```
+	 * @since v15.2.0, v14.17.0
+	 */
+	static getEventListeners(emitter: EventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
+	/**
+	 * Returns the currently set max amount of listeners.
+	 *
+	 * For `EventEmitter`s this behaves exactly the same as calling `.getMaxListeners` on
+	 * the emitter.
+	 *
+	 * For `EventTarget`s this is the only way to get the max event listeners for the
+	 * event target. If the number of event handlers on a single EventTarget exceeds
+	 * the max set, the EventTarget will print a warning.
+	 *
+	 * ```js
+	 * import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
+	 *
+	 * {
+	 *   const ee = new EventEmitter();
+	 *   console.log(getMaxListeners(ee)); // 10
+	 *   setMaxListeners(11, ee);
+	 *   console.log(getMaxListeners(ee)); // 11
+	 * }
+	 * {
+	 *   const et = new EventTarget();
+	 *   console.log(getMaxListeners(et)); // 10
+	 *   setMaxListeners(11, et);
+	 *   console.log(getMaxListeners(et)); // 11
+	 * }
+	 * ```
+	 * @since v19.9.0
+	 */
+	static getMaxListeners(emitter: EventTarget | NodeJS.EventEmitter): number;
+	/**
+	 * ```js
+	 * import { setMaxListeners, EventEmitter } from 'node:events';
+	 *
+	 * const target = new EventTarget();
+	 * const emitter = new EventEmitter();
+	 *
+	 * setMaxListeners(5, target, emitter);
+	 * ```
+	 * @since v15.4.0
+	 * @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
+	 * @param eventTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
+	 * objects.
+	 */
+	static setMaxListeners(n?: number, ...eventTargets: Array<EventTarget | NodeJS.EventEmitter>): void;
+	/**
+	 * Listens once to the `abort` event on the provided `signal`.
+	 *
+	 * Listening to the `abort` event on abort signals is unsafe and may
+	 * lead to resource leaks since another third party with the signal can
+	 * call `e.stopImmediatePropagation()`. Unfortunately Node.js cannot change
+	 * this since it would violate the web standard. Additionally, the original
+	 * API makes it easy to forget to remove listeners.
+	 *
+	 * This API allows safely using `AbortSignal`s in Node.js APIs by solving these
+	 * two issues by listening to the event such that `stopImmediatePropagation` does
+	 * not prevent the listener from running.
+	 *
+	 * Returns a disposable so that it may be unsubscribed from more easily.
+	 *
+	 * ```js
+	 * import { addAbortListener } from 'node:events';
+	 *
+	 * function example(signal) {
+	 *   let disposable;
+	 *   try {
+	 *     signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
+	 *     disposable = addAbortListener(signal, (e) => {
+	 *       // Do something when signal is aborted.
+	 *     });
+	 *   } finally {
+	 *     disposable?.[Symbol.dispose]();
+	 *   }
+	 * }
+	 * ```
+	 * @since v20.5.0
+	 * @return Disposable that removes the `abort` listener.
+	 */
+	static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
+	/**
+	 * This symbol shall be used to install a listener for only monitoring `'error'` events. Listeners installed using this symbol are called before the regular `'error'` listeners are called.
+	 *
+	 * Installing a listener using this symbol does not change the behavior once an `'error'` event is emitted. Therefore, the process will still crash if no
+	 * regular `'error'` listener is installed.
+	 * @since v13.6.0, v12.17.0
+	 */
+	static readonly errorMonitor: unique symbol;
+	/**
+	 * Value: `Symbol.for('nodejs.rejection')`
+	 *
+	 * See how to write a custom `rejection handler`.
+	 * @since v13.4.0, v12.16.0
+	 */
+	static readonly captureRejectionSymbol: unique symbol;
+	/**
+	 * Value: [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type)
+	 *
+	 * Change the default `captureRejections` option on all new `EventEmitter` objects.
+	 * @since v13.4.0, v12.16.0
+	 */
+	static captureRejections: boolean;
+	/**
+	 * By default, a maximum of `10` listeners can be registered for any single
+	 * event. This limit can be changed for individual `EventEmitter` instances
+	 * using the `emitter.setMaxListeners(n)` method. To change the default
+	 * for _all_`EventEmitter` instances, the `events.defaultMaxListeners` property
+	 * can be used. If this value is not a positive number, a `RangeError` is thrown.
+	 *
+	 * Take caution when setting the `events.defaultMaxListeners` because the
+	 * change affects _all_ `EventEmitter` instances, including those created before
+	 * the change is made. However, calling `emitter.setMaxListeners(n)` still has
+	 * precedence over `events.defaultMaxListeners`.
+	 *
+	 * This is not a hard limit. The `EventEmitter` instance will allow
+	 * more listeners to be added but will output a trace warning to stderr indicating
+	 * that a "possible EventEmitter memory leak" has been detected. For any single
+	 * `EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()` methods can be used to
+	 * temporarily avoid this warning:
+	 *
+	 * ```js
+	 * import { EventEmitter } from 'node:events';
+	 * const emitter = new EventEmitter();
+	 * emitter.setMaxListeners(emitter.getMaxListeners() + 1);
+	 * emitter.once('event', () => {
+	 *   // do stuff
+	 *   emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
+	 * });
+	 * ```
+	 *
+	 * The `--trace-warnings` command-line flag can be used to display the
+	 * stack trace for such warnings.
+	 *
+	 * The emitted warning can be inspected with `process.on('warning')` and will
+	 * have the additional `emitter`, `type`, and `count` properties, referring to
+	 * the event emitter instance, the event's name and the number of attached
+	 * listeners, respectively.
+	 * Its `name` property is set to `'MaxListenersExceededWarning'`.
+	 * @since v0.11.2
+	 */
+	static defaultMaxListeners: number;
+}
+declare namespace EventEmitter$1 {
+	// Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
+	export { EventEmitter$1 as EventEmitter$1 };
+	export interface Abortable {
+		/**
+		 * When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
+		 */
+		signal?: AbortSignal | undefined;
+	}
+	export interface EventEmitterReferencingAsyncResource extends AsyncResource {
+		readonly eventEmitter: EventEmitterAsyncResource;
+	}
+	export interface EventEmitterAsyncResourceOptions extends AsyncResourceOptions, EventEmitterOptions {
+		/**
+		 * The type of async event, this is required when instantiating `EventEmitterAsyncResource`
+		 * directly rather than as a child class.
+		 * @default new.target.name if instantiated as a child class.
+		 */
+		name?: string | undefined;
+	}
+	/**
+	 * Integrates `EventEmitter` with `AsyncResource` for `EventEmitter`s that
+	 * require manual async tracking. Specifically, all events emitted by instances
+	 * of `events.EventEmitterAsyncResource` will run within its `async context`.
+	 *
+	 * ```js
+	 * import { EventEmitterAsyncResource, EventEmitter } from 'node:events';
+	 * import { notStrictEqual, strictEqual } from 'node:assert';
+	 * import { executionAsyncId, triggerAsyncId } from 'node:async_hooks';
+	 *
+	 * // Async tracking tooling will identify this as 'Q'.
+	 * const ee1 = new EventEmitterAsyncResource({ name: 'Q' });
+	 *
+	 * // 'foo' listeners will run in the EventEmitters async context.
+	 * ee1.on('foo', () => {
+	 *   strictEqual(executionAsyncId(), ee1.asyncId);
+	 *   strictEqual(triggerAsyncId(), ee1.triggerAsyncId);
+	 * });
+	 *
+	 * const ee2 = new EventEmitter();
+	 *
+	 * // 'foo' listeners on ordinary EventEmitters that do not track async
+	 * // context, however, run in the same async context as the emit().
+	 * ee2.on('foo', () => {
+	 *   notStrictEqual(executionAsyncId(), ee2.asyncId);
+	 *   notStrictEqual(triggerAsyncId(), ee2.triggerAsyncId);
+	 * });
+	 *
+	 * Promise.resolve().then(() => {
+	 *   ee1.emit('foo');
+	 *   ee2.emit('foo');
+	 * });
+	 * ```
+	 *
+	 * The `EventEmitterAsyncResource` class has the same methods and takes the
+	 * same options as `EventEmitter` and `AsyncResource` themselves.
+	 * @since v17.4.0, v16.14.0
+	 */
+	export class EventEmitterAsyncResource extends EventEmitter$1 {
+		/**
+		 * @param options Only optional in child class.
+		 */
+		constructor(options?: EventEmitterAsyncResourceOptions);
+		/**
+		 * Call all `destroy` hooks. This should only ever be called once. An error will
+		 * be thrown if it is called more than once. This **must** be manually called. If
+		 * the resource is left to be collected by the GC then the `destroy` hooks will
+		 * never be called.
+		 */
+		emitDestroy(): void;
+		/**
+		 * The unique `asyncId` assigned to the resource.
+		 */
+		readonly asyncId: number;
+		/**
+		 * The same triggerAsyncId that is passed to the AsyncResource constructor.
+		 */
+		readonly triggerAsyncId: number;
+		/**
+		 * The returned `AsyncResource` object has an additional `eventEmitter` property
+		 * that provides a reference to this `EventEmitterAsyncResource`.
+		 */
+		readonly asyncResource: EventEmitterReferencingAsyncResource;
+	}
+	/**
+	 * The `NodeEventTarget` is a Node.js-specific extension to `EventTarget`
+	 * that emulates a subset of the `EventEmitter` API.
+	 * @since v14.5.0
+	 */
+	export interface NodeEventTarget extends EventTarget {
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that emulates the
+		 * equivalent `EventEmitter` API. The only difference between `addListener()` and
+		 * `addEventListener()` is that `addListener()` will return a reference to the
+		 * `EventTarget`.
+		 * @since v14.5.0
+		 */
+		addListener(type: string, listener: (arg: any) => void): this;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that dispatches the
+		 * `arg` to the list of handlers for `type`.
+		 * @since v15.2.0
+		 * @returns `true` if event listeners registered for the `type` exist,
+		 * otherwise `false`.
+		 */
+		emit(type: string, arg: any): boolean;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that returns an array
+		 * of event `type` names for which event listeners are registered.
+		 * @since 14.5.0
+		 */
+		eventNames(): string[];
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that returns the number
+		 * of event listeners registered for the `type`.
+		 * @since v14.5.0
+		 */
+		listenerCount(type: string): number;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that sets the number
+		 * of max event listeners as `n`.
+		 * @since v14.5.0
+		 */
+		setMaxListeners(n: number): void;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that returns the number
+		 * of max event listeners.
+		 * @since v14.5.0
+		 */
+		getMaxListeners(): number;
+		/**
+		 * Node.js-specific alias for `eventTarget.removeEventListener()`.
+		 * @since v14.5.0
+		 */
+		off(type: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+		/**
+		 * Node.js-specific alias for `eventTarget.addEventListener()`.
+		 * @since v14.5.0
+		 */
+		on(type: string, listener: (arg: any) => void): this;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that adds a `once`
+		 * listener for the given event `type`. This is equivalent to calling `on`
+		 * with the `once` option set to `true`.
+		 * @since v14.5.0
+		 */
+		once(type: string, listener: (arg: any) => void): this;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class. If `type` is specified,
+		 * removes all registered listeners for `type`, otherwise removes all registered
+		 * listeners.
+		 * @since v14.5.0
+		 */
+		removeAllListeners(type?: string): this;
+		/**
+		 * Node.js-specific extension to the `EventTarget` class that removes the
+		 * `listener` for the given `type`. The only difference between `removeListener()`
+		 * and `removeEventListener()` is that `removeListener()` will return a reference
+		 * to the `EventTarget`.
+		 * @since v14.5.0
+		 */
+		removeListener(type: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+	}
+}
+interface Presence {
+	/**
+	 * Subscribes to the given topic. The callback will be triggered whenever a message is published on topic.
+	 *
+	 * @param topic - Topic name.
+	 * @param callback - Callback to trigger on subscribing.
+	 */
+	subscribe(topic: string, callback: Function): Promise<this>;
+	/**
+	 * Unsubscribe from given topic.
+	 *
+	 * @param topic - Topic name.
+	 * @param callback - Callback to trigger on topic unsubscribing.
+	 */
+	unsubscribe(topic: string, callback?: Function): any;
+	/**
+	 * Lists the currently active channels / subscriptions
+	 * @param pattern
+	 */
+	channels(pattern?: string): Promise<string[]>;
+	/**
+	 * Posts a message to given topic.
+	 *
+	 * @param topic - Topic name.
+	 * @param data - Message body/object.
+	 */
+	publish(topic: string, data: any): any;
+	/**
+	 * Returns if key exists.
+	 *
+	 * @param key
+	 */
+	exists(key: string): Promise<boolean>;
+	/**
+	 * Set key to hold the string value.
+	 *
+	 * @param key - Identifier.
+	 * @param value - Message body/object.
+	 */
+	set(key: string, value: string): any;
+	/**
+	 * Set key to hold the string value and set key to timeout after a given number of seconds.
+	 *
+	 * @param key - Identifier.
+	 * @param value - Message body/object.
+	 * @param seconds - Timeout value.
+	 */
+	setex(key: string, value: string, seconds: number): any;
+	/**
+	 * Expire the key in seconds.
+	 *
+	 * @param key - Identifier.
+	 * @param seconds - Seconds to expire the key.
+	 */
+	expire(key: string, seconds: number): any;
+	/**
+	 * Get the value of key.
+	 *
+	 * @param key - Identifier.
+	 */
+	get(key: string): any;
+	/**
+	 * Removes the specified key.
+	 *
+	 * @param key - Identifier of the object to removed.
+	 */
+	del(key: string): void;
+	/**
+	 * Add the specified members to the set stored at key. Specified members that are already
+	 * a member of this set are ignored. If key does not exist, a new set is created before
+	 * adding the specified members.
+	 *
+	 * @param key - Name/Identifier of the set.
+	 * @param value - Message body/object.
+	 */
+	sadd(key: string, value: any): any;
+	/**
+	 * Returns all the members of the set value stored at key.
+	 *
+	 * @param key - Name/Identifier of the set.
+	 */
+	smembers(key: string): Promise<string[]>;
+	/**
+	 * Returns if member is a member of the set stored at key.
+	 *
+	 * @param key - Name/Identifier of the set.
+	 * @param field - Key value within the set.
+	 * @returns `1` if the element is a member of the set else `0`.
+	 */
+	sismember(key: string, field: string): any;
+	/**
+	 * Remove the specified members from the set stored at key. Specified members that are not a
+	 * member of this set are ignored. If key does not exist, it is treated as an empty set
+	 * and this command returns 0.
+	 *
+	 * @param key -  Name/Identifier of the set.
+	 * @param value - Key value within the set.
+	 */
+	srem(key: string, value: any): any;
+	/**
+	 * Returns the set cardinality (number of elements) of the set stored at key.
+	 *
+	 * @param key -  Name/Identifier of the set.
+	 */
+	scard(key: string): any;
+	/**
+	 * Returns the members of the set resulting from the intersection of all the given sets.
+	 *
+	 * @param keys - Key values within the set.
+	 */
+	sinter(...keys: string[]): Promise<string[]>;
+	/**
+	 * Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created.
+	 * If field already exists in the hash, it is overwritten.
+	 */
+	hset(key: string, field: string, value: string): Promise<boolean>;
+	/**
+	 * Increments the number stored at field in the hash stored at key by increment. If key does not exist, a new key
+	 * holding a hash is created. If field does not exist the value is set to 0 before the operation is performed.
+	 */
+	hincrby(key: string, field: string, value: number): Promise<number>;
+	/**
+	 * WARNING: DO NOT USE THIS METHOD. It is meant for internal use only.
+	 * @private
+	 */
+	hincrbyex(key: string, field: string, value: number, expireInSeconds: number): Promise<number>;
+	/**
+	 * Returns the value associated with field in the hash stored at key.
+	 */
+	hget(key: string, field: string): Promise<string | null>;
+	/**
+	 * Returns all fields and values of the hash stored at key.
+	 */
+	hgetall(key: string): Promise<{
+		[key: string]: string;
+	}>;
+	/**
+	 * Removes the specified fields from the hash stored at key. Specified fields that do not exist within
+	 * this hash are ignored. If key does not exist, it is treated as an empty hash and this command returns 0.
+	 */
+	hdel(key: string, field: string): Promise<boolean>;
+	/**
+	 * Returns the number of fields contained in the hash stored at key
+	 */
+	hlen(key: string): Promise<number>;
+	/**
+	 * Increments the number stored at key by one. If the key does not exist, it is set to 0 before performing
+	 * the operation. An error is returned if the key contains a value of the wrong type or
+	 * contains a string that can not be represented as integer. This operation is limited to 64-bit signed integers.
+	 */
+	incr(key: string): Promise<number>;
+	/**
+	 * Decrements the number stored at key by one. If the key does not exist, it is set to 0 before performing
+	 * the operation. An error is returned if the key contains a value of the wrong type or contains a string
+	 * that can not be represented as integer. This operation is limited to 64-bit signed integers.
+	 */
+	decr(key: string): Promise<number>;
+	/**
+	 * Returns the length of the list stored at key.
+	 */
+	llen(key: string): Promise<number>;
+	/**
+	 * Adds the string value to the end of the list stored at key. If key does not exist, it is created as empty list before performing the push operation.
+	 */
+	rpush(key: string, ...values: string[]): Promise<number>;
+	/**
+	 * Adds the string value to the begginning of the list stored at key. If key does not exist, it is created as empty list before performing the push operation.
+	 */
+	lpush(key: string, ...values: string[]): Promise<number>;
+	/**
+	 * Removes and returns the last element of the list stored at key.
+	 */
+	rpop(key: string): Promise<string | null>;
+	/**
+	 * Removes and returns the first element of the list stored at key.
+	 */
+	lpop(key: string): Promise<string | null>;
+	/**
+	 * Removes and returns the last element of the list stored at key. If the list is empty, the execution is halted until an element is available or the timeout is reached.
+	 */
+	brpop(...args: [
+		...keys: string[],
+		timeoutInSeconds: number
+	]): Promise<[
+		string,
+		string
+	] | null>;
+	setMaxListeners(number: number): void;
+	shutdown(): void;
+}
+type AuthContext = {
+	token?: string;
+	headers: Headers;
+	ip: string | string[];
+	req?: any;
+};
+interface ISendOptions {
+	afterNextPatch?: boolean;
+}
+declare const ClientState: {
+	readonly JOINING: 0;
+	readonly JOINED: 1;
+	readonly RECONNECTING: 2;
+	readonly RECONNECTED: 3;
+	readonly LEAVING: 4;
+	readonly CLOSED: 5;
+};
+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;
+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
+];
+interface Client$1<T extends {
+	userData?: any;
+	auth?: any;
+	messages?: Record<string | number, any>;
+} = any> {
+	"~messages": ExtractClientMessages<T>;
+	ref: EventEmitter$1;
+	/**
+	 * @deprecated use `sessionId` instead.
+	 */
+	id: string;
+	/**
+	 * Unique id per session.
+	 */
+	sessionId: string;
+	/**
+	 * Connection state
+	 */
+	state: ClientState;
+	/**
+	 * Optional: when using `@view()` decorator in your state properties, this will be the view instance for this client.
+	 */
+	view?: StateView;
+	/**
+	 * User-defined data can be attached to the Client instance through this variable.
+	 * - 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?: ExtractClientUserData<T>;
+	/**
+	 * auth data provided by your `onAuth`
+	 */
+	auth?: ExtractClientAuth<T>;
+	/**
+	 * Reconnection token used to re-join the room after onLeave + allowReconnection().
+	 *
+	 * IMPORTANT:
+	 *    This is not the full reconnection token the client provides for the server.
+	 *    The format provided by .reconnect() from the client-side must follow: "${roomId}:${reconnectionToken}"
+	 */
+	reconnectionToken: string;
+	raw(data: Uint8Array | Buffer, options?: ISendOptions, cb?: (err?: Error) => void): void;
+	enqueueRaw(data: Uint8Array | Buffer, options?: ISendOptions): void;
+	/**
+	 * Send a type of message to the client. Messages are encoded with MsgPack and can hold any
+	 * JSON-serializable data structure.
+	 *
+	 * @param type String or Number identifier the client SDK will use to receive this message
+	 * @param message Message payload. (automatically encoded with msgpack.)
+	 * @param options
+	 */
+	send<K extends keyof this["~messages"]>(type: K, ...args: MessageArgs<this["~messages"][K], ISendOptions>): void;
+	/**
+	 * Send raw bytes to this specific client.
+	 *
+	 * @param type String or Number identifier the client SDK will use to receive this message
+	 * @param bytes Raw byte array payload
+	 * @param options
+	 */
+	sendBytes(type: string | number, bytes: Buffer | Uint8Array, options?: ISendOptions): void;
+	/**
+	 * Disconnect this client from the room.
+	 *
+	 * @param code Custom close code. Default value is 1000.
+	 * @param data
+	 * @see [Leave room](https://docs.colyseus.io/room#leave-room)
+	 */
+	leave(code?: number, data?: string): void;
+	/**
+	 * @deprecated Use .leave() instead.
+	 */
+	close(code?: number, data?: string): void;
+	/**
+	 * Triggers `onError` with specified code to the client-side.
+	 *
+	 * @param code
+	 * @param message
+	 */
+	error(code: number, message?: string): void;
+}
+declare class ClientArray<C extends Client$1 = Client$1> extends Array<C> {
+	getById(sessionId: string): C | undefined;
+	delete(client: C): boolean;
+}
+interface Serializer$1<T> {
+	id: string;
+	reset(data: any): void;
+	getFullState(client?: Client$1): Uint8Array;
+	applyPatches(clients: Client$1[], state: T): boolean;
+	handshake?(): Uint8Array;
+}
+type SimulationCallback = (deltaTime: number) => void;
+interface RoomOptions {
+	state?: object;
+	metadata?: any;
+	client?: Client$1;
+}
+type ExtractRoomState<T> = T extends {
+	state?: infer S extends object;
+} ? S : any;
+type ExtractRoomMetadata<T> = T extends {
+	metadata?: infer M;
+} ? M : any;
+type ExtractRoomClient<T> = T extends {
+	client?: infer C extends Client$1;
+} ? C : Client$1;
+interface IBroadcastOptions extends ISendOptions {
+	except?: Client$1 | Client$1[];
+}
+type Messages$1<This extends Room$1> = Messages<This, Client$1>;
+declare class Room$1<T extends RoomOptions = RoomOptions> {
+	#private;
+	"~client": ExtractRoomClient<T>;
+	"~state": ExtractRoomState<T>;
+	"~metadata": ExtractRoomMetadata<T>;
+	/**
+	 * This property will change on these situations:
+	 * - The maximum number of allowed clients has been reached (`maxClients`)
+	 * - You manually locked, or unlocked the room using lock() or `unlock()`.
+	 *
+	 * @readonly
+	 */
+	get locked(): boolean;
+	/**
+	 * Get the room's matchmaking metadata.
+	 */
+	get metadata(): ExtractRoomMetadata<T>;
+	/**
+	 * Set the room's matchmaking metadata.
+	 *
+	 * **Note**: This setter does NOT automatically persist. Use `setMatchmaking()` for automatic persistence.
+	 *
+	 * @example
+	 * ```typescript
+	 * class MyRoom extends Room<{ metadata: { difficulty: string; rating: number } }> {
+	 *   async onCreate() {
+	 *     this.metadata = { difficulty: "hard", rating: 1500 };
+	 *   }
+	 * }
+	 * ```
+	 */
+	set metadata(meta: ExtractRoomMetadata<T>);
+	/**
+	 * The room listing cache for matchmaking.
+	 * @internal
+	 */
+	private _listing;
+	/**
+	 * Timing events tied to the room instance.
+	 * Intervals and timeouts are cleared when the room is disposed.
+	 */
+	clock: ClockTimer;
+	/**
+	 * Maximum number of clients allowed to connect into the room. When room reaches this limit,
+	 * it is locked automatically. Unless the room was explicitly locked by you via `lock()` method,
+	 * the room will be unlocked as soon as a client disconnects from it.
+	 */
+	maxClients: number;
+	/**
+	 * Automatically dispose the room when last client disconnects.
+	 *
+	 * @default true
+	 */
+	autoDispose: boolean;
+	/**
+	 * Frequency to send the room state to connected clients, in milliseconds.
+	 *
+	 * @default 50ms (20fps)
+	 */
+	patchRate: number | null;
+	/**
+	 * Maximum number of messages a client can send to the server per second.
+	 * If a client sends more messages than this, it will be disconnected.
+	 *
+	 * @default Infinity
+	 */
+	maxMessagesPerSecond: number;
+	/**
+	 * The state instance you provided to `setState()`.
+	 */
+	state: ExtractRoomState<T>;
+	/**
+	 * The presence instance. Check Presence API for more details.
+	 *
+	 * @see [Presence API](https://docs.colyseus.io/server/presence)
+	 */
+	presence: Presence;
+	/**
+	 * The array of connected clients.
+	 *
+	 * @see [Client instance](https://docs.colyseus.io/room#client)
+	 */
+	clients: ClientArray<ExtractRoomClient<T>>;
+	/**
+	 * Set the number of seconds a room can wait for a client to effectively join the room.
+	 * You should consider how long your `onAuth()` will have to wait for setting a different seat reservation time.
+	 * The default value is 15 seconds. You may set the `COLYSEUS_SEAT_RESERVATION_TIME`
+	 * environment variable if you'd like to change the seat reservation time globally.
+	 *
+	 * @default 15 seconds
+	 */
+	seatReservationTimeout: number;
+	private _events;
+	private _reservedSeats;
+	private _reservedSeatTimeouts;
+	private _reconnections;
+	private _reconnectionAttempts;
+	messages?: Messages$1<any>;
+	private onMessageEvents;
+	private onMessageValidators;
+	private onMessageFallbacks;
+	private _serializer;
+	private _afterNextPatchQueue;
+	private _simulationInterval;
+	private _internalState;
+	private _lockedExplicitly;
+	private _autoDisposeTimeout;
+	constructor();
+	/**
+	 * This method is called by the MatchMaker before onCreate()
+	 * @internal
+	 */
+	private __init;
+	/**
+	 * The name of the room you provided as first argument for `gameServer.define()`.
+	 *
+	 * @returns roomName string
+	 */
+	get roomName(): string;
+	/**
+	 * Setting the name of the room. Overwriting this property is restricted.
+	 *
+	 * @param roomName
+	 */
+	set roomName(roomName: string);
+	/**
+	 * A unique, auto-generated, 9-character-long id of the room.
+	 * You may replace `this.roomId` during `onCreate()`.
+	 *
+	 * @returns roomId string
+	 */
+	get roomId(): string;
+	/**
+	 * Setting the roomId, is restricted in room lifetime except upon room creation.
+	 *
+	 * @param roomId
+	 * @returns roomId string
+	 */
+	set roomId(roomId: string);
+	/**
+	 * This method is called before the latest version of the room's state is broadcasted to all clients.
+	 */
+	onBeforePatch?(state: ExtractRoomState<T>): void | Promise<any>;
+	/**
+	 * This method is called when the room is created.
+	 * @param options - The options passed to the room when it is created.
+	 */
+	onCreate?(options: any): void | Promise<any>;
+	/**
+	 * This method is called when a client joins the room.
+	 * @param client - The client that joined the room.
+	 * @param options - The options passed to the client when it joined the room.
+	 * @param auth - The data returned by the `onAuth` method - (Deprecated: use `client.auth` instead)
+	 */
+	onJoin?(client: ExtractRoomClient<T>, options?: any, auth?: any): void | Promise<any>;
+	/**
+	 * This method is called when a client leaves the room without consent.
+	 * You may allow the client to reconnect by calling `allowReconnection` within this method.
+	 *
+	 * @param client - The client that was dropped from the room.
+	 * @param code - The close code of the leave event.
+	 */
+	onDrop?(client: ExtractRoomClient<T>, code?: number): void | Promise<any>;
+	/**
+	 * This method is called when a client reconnects to the room.
+	 * @param client - The client that reconnected to the room.
+	 */
+	onReconnect?(client: ExtractRoomClient<T>): void | Promise<any>;
+	/**
+	 * This method is called when a client effectively leaves the room.
+	 * @param client - The client that left the room.
+	 * @param code - The close code of the leave event.
+	 */
+	onLeave?(client: ExtractRoomClient<T>, code?: number): void | Promise<any>;
+	/**
+	 * This method is called when the room is disposed.
+	 */
+	onDispose?(): void | Promise<any>;
+	/**
+	 * Define a custom exception handler.
+	 * If defined, all lifecycle hooks will be wrapped by try/catch, and the exception will be forwarded to this method.
+	 *
+	 * These methods will be wrapped by try/catch:
+	 * - `onMessage`
+	 * - `onAuth` / `onJoin` / `onLeave` / `onCreate` / `onDispose`
+	 * - `clock.setTimeout` / `clock.setInterval`
+	 * - `setSimulationInterval`
+	 *
+	 * (Experimental: this feature is subject to change in the future - we're currently getting feedback to improve it)
+	 */
+	onUncaughtException?(error: RoomException, methodName: RoomMethodName): void;
+	/**
+	 * This method is called before onJoin() - this is where you should authenticate the client
+	 * @param client - The client that is authenticating.
+	 * @param options - The options passed to the client when it is authenticating.
+	 * @param context - The authentication context, including the token and the client's IP address.
+	 * @returns The authentication result.
+	 *
+	 * @example
+	 * ```typescript
+	 * return {
+	 *   userId: 123,
+	 *   username: "John Doe",
+	 *   email: "john.doe@example.com",
+	 * };
+	 * ```
+	 */
+	onAuth(client: Client$1, options: any, context: AuthContext): any | Promise<any>;
+	static onAuth(token: string, options: any, context: AuthContext): Promise<unknown>;
+	/**
+	 * This method is called during graceful shutdown of the server process
+	 * You may override this method to dispose the room in your own way.
+	 *
+	 * Once process reaches room count of 0, the room process will be terminated.
+	 */
+	onBeforeShutdown(): void;
+	/**
+	 * devMode: When `devMode` is enabled, `onCacheRoom` method is called during
+	 * graceful shutdown.
+	 *
+	 * Implement this method to return custom data to be cached. `onRestoreRoom`
+	 * will be called with the data returned by `onCacheRoom`
+	 */
+	onCacheRoom?(): any;
+	/**
+	 * devMode: When `devMode` is enabled, `onRestoreRoom` method is called during
+	 * process startup, with the data returned by the `onCacheRoom` method.
+	 */
+	onRestoreRoom?(cached?: any): void;
+	/**
+	 * Returns whether the sum of connected clients and reserved seats exceeds maximum number of clients.
+	 *
+	 * @returns boolean
+	 */
+	hasReachedMaxClients(): boolean;
+	/**
+	 * @deprecated Use `seatReservationTimeout=` instead.
+	 */
+	setSeatReservationTime(seconds: number): this;
+	hasReservedSeat(sessionId: string, reconnectionToken?: string): boolean;
+	checkReconnectionToken(reconnectionToken: string): string;
+	/**
+	 * (Optional) Set a simulation interval that can change the state of the game.
+	 * The simulation interval is your game loop.
+	 *
+	 * @default 16.6ms (60fps)
+	 *
+	 * @param onTickCallback - You can implement your physics or world updates here!
+	 *  This is a good place to update the room state.
+	 * @param delay - Interval delay on executing `onTickCallback` in milliseconds.
+	 */
+	setSimulationInterval(onTickCallback?: SimulationCallback, delay?: number): void;
+	/**
+	 * @deprecated Use `.patchRate=` instead.
+	 */
+	setPatchRate(milliseconds: number | null): void;
+	/**
+	 * @deprecated Use `.state =` instead.
+	 */
+	setState(newState: ExtractRoomState<T>): void;
+	setSerializer(serializer: Serializer$1<ExtractRoomState<T>>): void;
+	setMetadata(meta: Partial<ExtractRoomMetadata<T>>, persist?: boolean): Promise<void>;
+	setPrivate(bool?: boolean, persist?: boolean): Promise<void>;
+	/**
+	 * Update multiple matchmaking/listing properties at once with a single persist operation.
+	 * This is the recommended way to update room listing properties.
+	 *
+	 * @param updates - Object containing the properties to update
+	 *
+	 * @example
+	 * ```typescript
+	 * // Update multiple properties at once
+	 * await this.setMatchmaking({
+	 *   metadata: { difficulty: "hard", rating: 1500 },
+	 *   private: true,
+	 *   locked: true,
+	 *   maxClients: 10
+	 * });
+	 * ```
+	 *
+	 * @example
+	 * ```typescript
+	 * // Update only metadata
+	 * await this.setMatchmaking({
+	 *   metadata: { status: "in_progress" }
+	 * });
+	 * ```
+	 *
+	 * @example
+	 * ```typescript
+	 * // Partial metadata update (merges with existing)
+	 * await this.setMatchmaking({
+	 *   metadata: { ...this.metadata, round: this.metadata.round + 1 }
+	 * });
+	 * ```
+	 */
+	setMatchmaking(updates: {
+		metadata?: ExtractRoomMetadata<T>;
+		private?: boolean;
+		locked?: boolean;
+		maxClients?: number;
+		unlisted?: boolean;
+		[key: string]: any;
+	}): Promise<void>;
+	/**
+	 * Lock the room. This prevents new clients from joining this room.
+	 */
+	lock(): Promise<void>;
+	/**
+	 * Unlock the room. This allows new clients to join this room, if maxClients is not reached.
+	 */
+	unlock(): Promise<void>;
+	/**
+	 * @deprecated Use `client.send(...)` instead.
+	 */
+	send(client: Client$1, type: string | number, message: any, options?: ISendOptions): void;
+	/**
+	 * Broadcast a message to all connected clients.
+	 * @param type - The type of the message.
+	 * @param message - The message to broadcast.
+	 * @param options - The options for the broadcast.
+	 *
+	 * @example
+	 * ```typescript
+	 * this.broadcast('message', { message: 'Hello, world!' });
+	 * ```
+	 */
+	broadcast<K extends keyof ExtractRoomClient<T>["~messages"] & string | number>(type: K, ...args: MessageArgs<ExtractRoomClient<T>["~messages"][K], IBroadcastOptions>): void;
+	/**
+	 * Broadcast bytes (UInt8Arrays) to a particular room
+	 */
+	broadcastBytes(type: string | number, message: Uint8Array, options: IBroadcastOptions): void;
+	/**
+	 * Checks whether mutations have occurred in the state, and broadcast them to all connected clients.
+	 */
+	broadcastPatch(): boolean;
+	/**
+	 * Register a message handler for a specific message type.
+	 * This method is used to handle messages sent by clients to the room.
+	 * @param messageType - The type of the message.
+	 * @param callback - The callback to call when the message is received.
+	 * @returns A function to unbind the callback.
+	 *
+	 * @example
+	 * ```typescript
+	 * this.onMessage('message', (client, message) => {
+	 *   console.log(message);
+	 * });
+	 * ```
+	 *
+	 * @example
+	 * ```typescript
+	 * const unbind = this.onMessage('message', (client, message) => {
+	 *   console.log(message);
+	 * });
+	 *
+	 * // Unbind the callback when no longer needed
+	 * unbind();
+	 * ```
+	 */
+	onMessage<T = any, C extends Client$1 = ExtractRoomClient<T>>(messageType: "*", callback: (client: C, type: string | number, message: T) => void): any;
+	onMessage<T = any, C extends Client$1 = ExtractRoomClient<T>>(messageType: string | number, callback: (client: C, message: T) => void): any;
+	onMessage<T = any, C extends Client$1 = ExtractRoomClient<T>>(messageType: string | number, validationSchema: StandardSchemaV1<T>, callback: (client: C, message: T) => void): any;
+	onMessageBytes<T = any, C extends Client$1 = ExtractRoomClient<T>>(messageType: string | number, callback: (client: C, message: T) => void): any;
+	onMessageBytes<T = any, C extends Client$1 = ExtractRoomClient<T>>(messageType: string | number, validationSchema: StandardSchemaV1<T>, callback: (client: C, message: T) => void): any;
+	/**
+	 * Disconnect all connected clients, and then dispose the room.
+	 *
+	 * @param closeCode WebSocket close code (default = 4000, which is a "consented leave")
+	 * @returns Promise<void>
+	 */
+	disconnect(closeCode?: number): Promise<any>;
+	private _onJoin;
+	/**
+	 * Allow the specified client to reconnect into the room. Must be used inside `onLeave()` method.
+	 * If seconds is provided, the reconnection is going to be cancelled after the provided amount of seconds.
+	 *
+	 * @param client - The client that is allowed to reconnect into the room.
+	 * @param seconds - The time in seconds that the client is allowed to reconnect into the room.
+	 *
+	 * @returns Deferred<Client> - The differed is a promise like type.
+	 *  This type can forcibly reject the promise by calling `.reject()`.
+	 *
+	 * @example
+	 * ```typescript
+	 * onDrop(client: Client, code: CloseCode) {
+	 *   // Allow the client to reconnect into the room with a 15 seconds timeout.
+	 *   this.allowReconnection(client, 15);
+	 * }
+	 * ```
+	 */
+	allowReconnection(previousClient: Client$1, seconds: number | "manual"): Deferred<Client$1>;
+	private resetAutoDisposeTimeout;
+	private broadcastMessageType;
+	private sendFullState;
+	private _dequeueAfterPatchMessages;
+	private _reserveSeat;
+	private _reserveMultipleSeats;
+	private _onMessage;
+	private _onLeave;
+}
+type RoomMethodName = "onCreate" | "onAuth" | "onJoin" | "onLeave" | "onDrop" | "onReconnect" | "onDispose" | "onMessage" | "setSimulationInterval" | "setInterval" | "setTimeout";
+type RoomException<R extends Room$1 = Room$1> = OnCreateException<R> | OnAuthException<R> | OnJoinException<R> | OnLeaveException<R> | OnDropException<R> | OnReconnectException<R> | OnDisposeException | OnMessageException<R> | SimulationIntervalException | TimedEventException;
+declare class OnCreateException<R extends Room$1 = Room$1> extends Error {
+	options: Parameters<R["onCreate"]>[0];
+	constructor(cause: Error, message: string, options: Parameters<R["onCreate"]>[0]);
+}
+declare class OnAuthException<R extends Room$1 = Room$1> extends Error {
+	client: Parameters<R["onAuth"]>[0];
+	options: Parameters<R["onAuth"]>[1];
+	constructor(cause: Error, message: string, client: Parameters<R["onAuth"]>[0], options: Parameters<R["onAuth"]>[1]);
+}
+declare class OnJoinException<R extends Room$1 = Room$1> extends Error {
+	client: Parameters<R["onJoin"]>[0];
+	options: Parameters<R["onJoin"]>[1];
+	auth: Parameters<R["onJoin"]>[2];
+	constructor(cause: Error, message: string, client: Parameters<R["onJoin"]>[0], options: Parameters<R["onJoin"]>[1], auth: Parameters<R["onJoin"]>[2]);
+}
+declare class OnLeaveException<R extends Room$1 = Room$1> extends Error {
+	client: Parameters<R["onLeave"]>[0];
+	consented: Parameters<R["onLeave"]>[1];
+	constructor(cause: Error, message: string, client: Parameters<R["onLeave"]>[0], consented: Parameters<R["onLeave"]>[1]);
+}
+declare class OnDropException<R extends Room$1 = Room$1> extends Error {
+	client: Parameters<R["onDrop"]>[0];
+	code: Parameters<R["onDrop"]>[1];
+	constructor(cause: Error, message: string, client: Parameters<R["onDrop"]>[0], code: Parameters<R["onDrop"]>[1]);
+}
+declare class OnReconnectException<R extends Room$1 = Room$1> extends Error {
+	client: Parameters<R["onReconnect"]>[0];
+	constructor(cause: Error, message: string, client: Parameters<R["onReconnect"]>[0]);
+}
+declare class OnDisposeException extends Error {
+	constructor(cause: Error, message: string);
+}
+declare class OnMessageException<R extends Room$1, 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>;
+}
+declare class SimulationIntervalException extends Error {
+	constructor(cause: Error, message: string);
+}
+declare class TimedEventException extends Error {
+	args: any[];
+	constructor(cause: Error, message: string, ...args: any[]);
+}
+type Type<T> = new (...args: any[]) => T;
+declare class Deferred<T = any> {
+	promise: Promise<T>;
+	resolve: Function;
+	reject: Function;
+	constructor(promise?: Promise<T>);
+	then(onFulfilled?: (value: T) => any, onRejected?: (reason: any) => any): Promise<any>;
+	catch(func: (value: any) => any): Promise<any>;
+	static reject(reason?: any): Deferred<never>;
+	static resolve<T = any>(value?: T): Deferred<T>;
+}
+interface SortOptions {
+	[fieldName: string]: 1 | -1 | "asc" | "desc" | "ascending" | "descending";
+}
+type IRoomCacheSortByKeys = "clients" | "maxClients" | "createdAt";
+type IRoomCacheFilterByKeys = "clients" | "maxClients" | "processId";
+type ExtractRoomCacheMetadata<RoomType extends Room$1> = RoomType["~metadata"];
+type FilterByKeys<RoomType extends Room$1> = IRoomCacheFilterByKeys | (ExtractRoomCacheMetadata<RoomType> extends object ? keyof ExtractRoomCacheMetadata<RoomType> & string : never);
+type SortByKeys<RoomType extends Room$1> = IRoomCacheSortByKeys | (ExtractRoomCacheMetadata<RoomType> extends object ? keyof ExtractRoomCacheMetadata<RoomType> & string : never);
+interface RegisteredHandlerEvents<RoomType extends Room$1 = any> {
+	create: [
+		room: RoomType
+	];
+	lock: [
+		room: RoomType
+	];
+	unlock: [
+		room: RoomType
+	];
+	join: [
+		room: RoomType,
+		client: Client$1
+	];
+	leave: [
+		room: RoomType,
+		client: Client$1,
+		willDispose: boolean
+	];
+	dispose: [
+		room: RoomType
+	];
+	"visibility-change": [
+		room: RoomType,
+		isVisible: boolean
+	];
+	"metadata-change": [
+		room: RoomType
+	];
+}
+declare class RegisteredHandler<RoomType extends Room$1 = any> extends EventEmitter$1<RegisteredHandlerEvents<RoomType>> {
+	"~room": RoomType;
+	klass: Type<RoomType>;
+	options: any;
+	name: string;
+	filterOptions: Array<FilterByKeys<RoomType>>;
+	sortOptions?: SortOptions;
+	realtimeListingEnabled: boolean;
+	constructor(klass: Type<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<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<RoomType>>(options: {
+		[K in T]: SortOptions[string];
+	}): this;
+	getMetadataFromOptions(options: any): {
+		metadata: {};
+	} | {
+		metadata?: undefined;
+	};
+	/**
+	 * Extract filter options from client options.
+	 */
+	getFilterOptions(options: any): {};
+}
+interface SDKTypes$1<RoomTypes extends Record<string, RegisteredHandler> = any, Routes extends Router = any> extends SDKTypes<RoomTypes, Routes> {
+}
+/**
+ * Infer the room constructor from ServerType based on the instance type.
+ * This allows proper type inference for SDK Room methods like `send()` and `onMessage()`.
+ */
+export type InferRoomConstructor<ServerType extends SDKTypes$1, Instance> = ServerType extends SDKTypes$1<infer Rooms> ? {
+	[K in keyof Rooms]: Instance extends InstanceType<Rooms[K]["~room"]> ? Rooms[K]["~room"] : never;
+}[keyof Rooms] : // Fallback: create a synthetic constructor type from the instance
+(typeof Room$1) & {
+	prototype: Instance;
+};
+
+export {
+	ISeatReservation as SeatReservation,
+};
+
+export as namespace Colyseus;
+
+export {};