/**
 * GameEngine — HoloScript+ Top-Level Runtime Facade
 *
 * Composes GameLoop + AssetPipeline + HotReloadManager into a
 * single ergonomic entry point:
 *
 *   const engine = new GameEngine();
 *   engine.addUpdateHandler('physics', myPhysicsFn);
 *   engine.start();
 *   // ...
 *   engine.stop();
 *
 * The engine does NOT depend on a renderer or HoloScript parser directly —
 * it provides lifecycle hooks so the caller can wire those in.
 *
 * @module runtime/GameEngine
 * @version 1.0.0
 */
import { GameLoop, type GameLoopOptions } from './GameLoop';
import { AssetPipeline, type AssetLoader } from './AssetPipeline';
import { HotReloadManager, type ReloadWatcher } from './HotReloadManager';
export type UpdateHandler = (delta: number, frame: number) => void;
export type EnginePhase = 'idle' | 'running' | 'paused' | 'stopped';
export interface GameEngineOptions extends Omit<GameLoopOptions, 'onUpdate'> {
    /** Enable hot-reload watcher integration. Default: false */
    hotReload?: boolean;
}
export interface EngineStats {
    phase: EnginePhase;
    frame: number;
    fps: number;
    assetCount: number;
}
export declare class GameEngine {
    readonly loop: GameLoop;
    readonly assets: AssetPipeline;
    readonly hotReload: HotReloadManager;
    private _phase;
    private _updateHandlers;
    private _frame;
    private _lastTickTime;
    private _fps;
    constructor(options?: GameEngineOptions);
    /** Start the engine (and the internal game loop). */
    start(): void;
    /** Stop the engine permanently. */
    stop(): void;
    /** Pause the update loop (keep state intact). */
    pause(): void;
    /** Resume from paused state. */
    resume(): void;
    /**
     * Register a named update handler that runs every tick.
     * Multiple handlers run in insertion order.
     */
    addUpdateHandler(name: string, fn: UpdateHandler): void;
    /** Remove a previously-registered update handler. */
    removeUpdateHandler(name: string): boolean;
    /** List all registered handler names. */
    getHandlerNames(): string[];
    /**
     * Register a typed asset loader and return the engine (fluent API).
     * Delegates to this.assets.registerLoader().
     */
    registerLoader<T = unknown>(type: string, loader: AssetLoader<T>): this;
    /**
     * Preload an asset by type and path. Resolves when loaded or throws.
     * Delegates to this.assets.load().
     */
    preload<T = unknown>(type: string, path: string): Promise<T>;
    /**
     * Watch a module by key. On reload, the watcher fn is called.
     * Returns an unsubscribe function.
     */
    watch(key: string, fn: ReloadWatcher): () => void;
    /**
     * Trigger a hot-reload for the given key.
     */
    reload<TContent = unknown, TState = unknown>(key: string, content: TContent, oldState?: TState): void;
    get phase(): EnginePhase;
    get frame(): number;
    get fps(): number;
    /** Snapshot of engine state for debugging/telemetry. */
    getStats(): EngineStats;
    private _onUpdate;
}
export default GameEngine;
//# sourceMappingURL=GameEngine.d.ts.map