import type { Observable } from "rxjs";
import { IframeApiContribution } from "./IframeApiContribution";
import type { RemotePlayerInterface, RemotePlayerMoved } from "./Players/RemotePlayer";
import { RemotePlayer } from "./Players/RemotePlayer";
import type { PublicPlayerState } from "./PublicPlayerState";
export interface PlayerVariableChanged<V> {
    player: RemotePlayer;
    value: V;
}
export declare class WorkadventurePlayersCommands extends IframeApiContribution<WorkadventurePlayersCommands> {
    private trackingPlayers;
    private trackingMovement;
    private sharedPlayersVariableStream;
    private remotePlayers;
    private _newRemotePlayersStream;
    private newRemotePlayersStream;
    private _removeRemotePlayersStream;
    private removeRemotePlayersStream;
    private _playersMovedStream;
    private playersMovedStream;
    callbacks: ({
        type: "setSharedPlayerVariable";
        callback: (event: {
            playerId: number;
            key: string;
            value?: unknown;
        }) => void;
    } | {
        type: "addRemotePlayer";
        callback: (event: {
            name: string;
            position: {
                x: number;
                y: number;
            };
            playerId: number;
            variables: Map<string, unknown>;
            userUuid: string;
            availabilityStatus: string;
            outlineColor?: number | undefined;
            chatID?: string | null | undefined;
        }) => void;
    } | {
        type: "removeRemotePlayer";
        callback: (event: number) => void;
    } | {
        type: "remotePlayerChanged";
        callback: (event: {
            playerId: number;
            name?: string | undefined;
            position?: {
                x: number;
                y: number;
            } | undefined;
            variables?: Map<string, unknown> | undefined;
            availabilityStatus?: string | undefined;
            outlineColor?: number | undefined;
            chatID?: string | null | undefined;
        }) => void;
    })[];
    private registerRemotePlayer;
    /**
     * Start the tracking players. You need to call this method before being able to listen to players positions.
     * {@link https://docs.workadventu.re/map-building/api-players.md#enabling-players-tracking | Website documentation}
     *
     * ```ts
     * await WA.players.configureTracking({
     *     players: true, // Required to use "onPlayerEnters", "onPlayerLeaves", "list" and "get"
     *     movement: true, // Required to get the player position and use "onPlayerMoves"
     * })
     * ```
     *
     * @param options
     */
    configureTracking(options?: {
        players?: boolean;
        movement?: boolean;
    }): Promise<void>;
    /**
     * Listens to a given variable change on all available players.
     * {@link https://docs.workadventu.re/map-building/api-players.md#listen-to-a-remote-player-variable-changes | Website documentation}
     *
     * ```ts
     * WA.players.onVariableChange("score").subscribe({ player, value } => {
     *     console.info("Score for player", player.name, "has been updated to", value);
     * });
     * ```
     *
     * If you are looking to listen for variable changes of only one player, look at `RemotePlayer.onVariableChange` instead.
     */
    onVariableChange<K extends keyof PublicPlayerState>(variableName: K): Observable<PlayerVariableChanged<PublicPlayerState[K]>>;
    /**
     * Listens to new remote players.
     * These will be triggered when a remote player is entering our "zone" (zone ~= viewport)
     * This means this will NOT be triggered when a remote player enters the map, but when the remote player is
     * getting visible.
     * {@link https://docs.workadventu.re/map-building/api-players.md#tracking-players-in-real-time | Website documentation}
     *
     * Usage:
     *
     * ```
     * WA.players.onPlayerEnters.subscribe((remotePlayer) => { doStuff(); });
     * ```
     */
    get onPlayerEnters(): Observable<RemotePlayerInterface>;
    /**
     * Listens to remote players leaving.
     * These will be triggered when a remote player is leaving our "zone" (zone ~= viewport)
     * This means this will be triggered when a remote player leaves the map, but ALSO when the remote player is
     * walking away and is no longer visible.
     * {@link https://docs.workadventu.re/map-building/api-players.md#tracking-players-in-real-time | Website documentation}
     *
     * Usage:
     *
     * ```
     * WA.players.onPlayerLeaves.subscribe((remotePlayer) => { doCleanupStuff(); });
     * ```
     */
    get onPlayerLeaves(): Observable<RemotePlayerInterface>;
    /**
     * Listens to movement from all players who are in our zone (zone ~= viewport)
     * This means this may NOT be triggered when a remote player moves but is far away from us.
     * {@link https://docs.workadventu.re/map-building/api-players.md#tracking-players-movement | Website documentation}
     *
     * Usage:
     *
     * ```
     * WA.players.onPlayerMoves.subscribe(({ player, newPosition, oldPosition }) => { doStuff(); });
     * ```
     */
    get onPlayerMoves(): Observable<RemotePlayerMoved>;
    /**
     * Returns a RemotePlayer by its id.
     * {@link https://docs.workadventu.re/map-building/api-players.md#getting-a-remote-player-by-id | Website documentation}
     *
     * Note: if the same user is connected twice, it will be considered as 2 different players with 2 different IDs.
     */
    get(id: number): RemotePlayerInterface | undefined;
    /**
     * Returns the list of all nearby remote players.
     * The list only contains the players in the same zone as the current player (where zone ~= viewport).
     * {@link https://docs.workadventu.re/map-building/api-players.md#getting-a-list-of-players-around-me | Website documentation}
     */
    list(): IterableIterator<RemotePlayerInterface>;
}
declare const _default: WorkadventurePlayersCommands;
export default _default;