/**
 * SpatialEngine.ts
 *
 * Top-level game loop orchestrator. Owns the requestAnimationFrame loop
 * and ticks subsystems in deterministic order:
 *   1. Input  →  2. Network  →  3. Physics (fixed step)
 *   4. Animation  →  5. Scene graph update  →  6. Cull  →  7. Render
 *
 * @module engine
 */
export interface EngineConfig {
    /** Target frames per second (0 = uncapped). */
    targetFPS: number;
    /** Fixed physics timestep in seconds (default 1/60). */
    physicsTimestep: number;
    /** Maximum accumulated physics time per frame (prevents spiral-of-death). */
    maxPhysicsAccumulator: number;
    /** Enable performance metrics collection. */
    metrics: boolean;
}
export interface EngineMetrics {
    fps: number;
    frameTimeMs: number;
    physicsTimeMs: number;
    renderTimeMs: number;
    entityCount: number;
    drawCalls: number;
    frameNumber: number;
}
export type EngineState = 'stopped' | 'running' | 'paused';
export interface EngineSystem {
    /** Called once when the engine starts. */
    init?(): void | Promise<void>;
    /** Called every frame with delta time in seconds. */
    update?(dt: number): void;
    /** Called at fixed intervals for physics. */
    fixedUpdate?(dt: number): void;
    /** Called after scene graph update, before render. */
    lateUpdate?(dt: number): void;
    /** Called when the engine stops. */
    destroy?(): void;
    /** Priority (lower = earlier). Default 0. */
    priority?: number;
    /** Human-readable system name. */
    name: string;
}
export declare class SpatialEngine {
    private config;
    private state;
    private systems;
    private rafId;
    private lastTime;
    private physicsAccumulator;
    private frameNumber;
    private metrics;
    private frameTimes;
    private readonly FRAME_SAMPLE_SIZE;
    constructor(config?: Partial<EngineConfig>);
    /** Register a system. Systems are sorted by priority on start. */
    addSystem(system: EngineSystem): this;
    /** Remove a system by name. */
    removeSystem(name: string): boolean;
    /** Get a registered system by name. */
    getSystem<T extends EngineSystem>(name: string): T | undefined;
    /** Initialize all systems and start the game loop. */
    start(): Promise<void>;
    /** Pause the game loop (systems stay alive). */
    pause(): void;
    /** Resume from paused state. */
    resume(): void;
    /** Stop the engine and destroy all systems. */
    stop(): void;
    getState(): EngineState;
    getMetrics(): Readonly<EngineMetrics>;
    getConfig(): Readonly<EngineConfig>;
    private scheduleFrame;
    private tick;
    /**
     * Step the engine by a given delta (in seconds).
     * Useful for deterministic testing without requestAnimationFrame.
     */
    stepManual(dt: number): void;
}
//# sourceMappingURL=SpatialEngine.d.ts.map