import { RpgRoomDescriptor, RpgWritableSignal } from '@rpgjs/common';
import { RpgPlayer } from '../Player/Player';
import { BaseRoom } from './BaseRoom';
import { RpgRoomConnection } from './map';
/**
 * Map-independent gameplay room with RPGJS players and synchronized state.
 *
 * The server owns `state`; clients receive it through `RpgClientRoom`. This
 * class deliberately excludes maps, events, movement, collisions, physics,
 * projectiles, and map loading. It works in standalone and MMORPG modes.
 *
 * @example
 * ```ts
 * @RpgRoom({
 *   kind: "battle",
 *   path: "battle-{id}",
 *   initialState: () => ({ turn: 1 }),
 * })
 * class BattleRoom extends RpgGameplayRoom<{ turn: number }> {
 *   @RpgRoomAction("battle.nextTurn")
 *   nextTurn() {
 *     this.state.update((state) => ({ turn: state.turn + 1 }))
 *   }
 * }
 * ```
 */
export declare class RpgGameplayRoom<TState = Record<string, unknown>> extends BaseRoom {
    /** Low-level room id resolved from the registered path. */
    readonly id: string;
    /** Path parameters extracted by the room runtime. */
    readonly params: Readonly<Record<string, string>>;
    /** Serializable identity shared with the client scene. */
    readonly descriptor: RpgRoomDescriptor;
    /** Players connected to this room, synchronized by the room runtime. */
    players: RpgWritableSignal<Record<string, RpgPlayer>>;
    /** Server-authoritative state synchronized with every connected client. */
    state: RpgWritableSignal<TState>;
    /** Whether Signe should automatically publish synchronized state changes. */
    autoSync: boolean;
    private readonly clientListeners;
    constructor(room: {
        id?: string;
        env?: Record<string, unknown>;
    }, params?: Record<string, string>);
    onSessionRestore(payload: {
        userSnapshot: unknown;
        user?: RpgPlayer;
    }): Promise<unknown>;
    onJoin(player: RpgPlayer, conn: RpgRoomConnection): Promise<void>;
    onLeave(player: RpgPlayer, conn?: RpgRoomConnection | null): Promise<void>;
    /** Subscribe to an ephemeral client action not handled by a decorated method. */
    on<T = unknown>(type: string, listener: (player: RpgPlayer, data: T) => void | Promise<void>): void;
    /** Remove every room listener registered for an ephemeral client action. */
    off(type: string): void;
    /** Broadcast an ephemeral packet to every client connected to this room. */
    broadcast<T = unknown>(type: string, value?: T): void;
    guiInteraction(player: RpgPlayer, value: {
        guiId: string;
        name: string;
        data: unknown;
    }): Promise<void>;
    guiExit(player: RpgPlayer, value: {
        guiId: string;
        data?: unknown;
        guiOpenId?: unknown;
    }): void;
    onUnhandledAction(player: RpgPlayer, message: {
        action: string;
        value: unknown;
    }): Promise<void>;
}
export interface RpgGameplayRoom<TState = Record<string, unknown>> {
    $applySync(): void;
    $broadcast(packet: unknown, without?: string[]): void;
    $send(connection: RpgRoomConnection, packet: unknown): void;
    $sessionTransfer(connection: RpgRoomConnection, roomId: string): Promise<unknown>;
}