import { App } from "../core/App";
import type { Emitter } from "../core/emitter";
import type { Entity } from "../core/Entity";
import type { TerrainInterface } from "./entities/Terrain";
import type { Obstruction } from "./entities/widgets/sprites/units/Obstruction";
import { Alliances } from "./mechanisms/Alliances";
import { FPSMonitor } from "./mechanisms/FPSMonitor";
import { ObstructionPlacement } from "./mechanisms/ObstructionPlacement";
import type { ConnectionEvent, Network } from "./Network";
import { Player } from "./players/Player";
import { Mouse } from "./systems/Mouse";
import type { PathingSystem } from "./systems/PathingSystem";
import { SelectedSystem } from "./systems/SelectedSystem";
import { ThreeGraphics } from "./systems/ThreeGraphics";
import { TimerWindows } from "./systems/TimerWindows";
import { Hotkeys } from "./ui/hotkeys";
import { UI } from "./ui/index";
declare type IntervalId = number;
declare type TimeoutId = number;
declare type Interval = {
    fn: () => void;
    next: number;
    interval: number;
    oncePerUpdate: boolean;
    id: number;
};
declare type Timeout = {
    fn: () => void;
    next: number;
    id: number;
};
declare class Game extends App {
    static readonly isGame = true;
    static displayName: string;
    static protocol: string;
    get displayName(): string;
    get protocol(): string;
    private network;
    addNetworkListener: Network["addEventListener"];
    removeNetworkListener: Network["removeEventListener"];
    connect: Network["connect"];
    ui: UI;
    localPlayer: Player;
    host?: Player;
    players: Player[];
    synchronizationState: "synchronizing" | "synchronized";
    newPlayers: boolean;
    random: import("./lib/alea").AleaNext;
    lastUpdate: number;
    terrain?: TerrainInterface;
    mouse: Mouse;
    actions: Hotkeys;
    obstructionPlacement: ObstructionPlacement;
    graphics: ThreeGraphics;
    selectionSystem: SelectedSystem;
    alliances: Alliances;
    fpsMonitor: FPSMonitor;
    timerWindows: TimerWindows;
    pathingSystem?: PathingSystem;
    intervals: Interval[];
    nextIntervalId: number;
    timeouts: Timeout[];
    nextTimeoutId: number;
    constructor(network: Network);
    get __UNSAFE_network(): Network;
    transmit<T extends Record<string, unknown>>(data: T): void;
    get isHost(): boolean;
    setInterval(fn: () => void, interval?: number, oncePerUpdate?: boolean): IntervalId;
    clearInterval(id: number): void;
    setTimeout(fn: () => void, timeout?: number): TimeoutId;
    clearTimeout(id: number): void;
    updateIntervals(time: number): void;
    updateTimeouts(time: number): void;
    onPlayerJoin(data: ConnectionEvent): Player;
    onPlayerLeave(player: Player): void;
    remove(entity: Entity): boolean;
    render(): void;
    protected _update(e: {
        time: number;
    }): void;
    update(e: {
        time: number;
    }): void;
    toJSON(): {
        lastUpdate: number;
        players: ReturnType<typeof Player.prototype.toJSON>[];
        entityId: number;
    };
}
export declare type GameEvents = {
    update: (time: number) => void;
    selection: (selection: Entity[]) => void;
    build: (builder: Entity, obstruction: Obstruction) => void;
    [key: string]: (...args: any[]) => void;
};
interface Game extends Emitter<GameEvents>, App {
}
export { Game };