declare class RouteManager {
    private routes;
    /**
     * Register a route
     * @param path Path pattern (e.g. "/player/:id")
     * @param sceneName Name of the scene to map to
     */
    register(path: string, sceneName: string): void;
    /**
     * Validate route registration inputs
     */
    private validateRouteInputs;
    /**
     * Match a path to a route
     * @param path Path to match against registered routes
     * @returns Route match with scene name and params, or null if no match
     */
    match(path: string): {
        sceneName: string;
        params: Record<string, string>;
    } | null;
    /**
     * Try to match a single route against a path
     */
    private tryMatchRoute;
    /**
     * Extract route parameters from regex match
     */
    private extractParams;
    /**
     * Parse path pattern to regex
     * Converts route patterns like "/player/:id" to regex
     */
    private parsePath;
    /**
     * Clear all routes
     */
    clear(): void;
}

/**
 * Type definitions for Scene Management System
 */
/**
 * Route definition for matching paths to scenes
 */
interface RouteDefinition {
    /** Path pattern (e.g., "/player/:id") */
    path: string;
    /** Name of the scene to map to */
    sceneName: string;
    /** Compiled regex for matching */
    regex: RegExp;
    /** Parameter keys extracted from path */
    keys: string[];
}
/**
 * Scene definition with lifecycle methods
 */
interface SceneDefinition {
    /** Initialize scene (called once when scene is first registered) */
    init?: () => void;
    /** Called when scene becomes active */
    onEnter?: (params?: Record<string, string>) => void;
    /** Called when scene is deactivated */
    onLeave?: () => void;
    /** Update loop (called every frame) */
    update?: () => void;
    /** Draw loop (called every frame) */
    draw?: () => void;
    /** Internal flag to track initialization */
    _initialized?: boolean;
}
/**
 * Scene status enumeration
 */
type SceneStatus = "idle" | "active" | "transitioning";
/**
 * Scene data container
 */
interface SceneData {
    /** Scene name */
    name: string;
    /** Scene definition */
    definition: SceneDefinition;
    /** Route parameters */
    params?: Record<string, string>;
}
/**
 * Router state
 */
interface RouterState {
    /** Current path */
    path: string;
    /** Route parameters */
    params: Record<string, string>;
    /** Current scene name */
    sceneName: string | null;
}
/**
 * Scene manager options
 */
interface SceneManagerOptions {
    /** Initial scene name */
    initialScene?: string;
    /** Enable debug logging */
    debug?: boolean;
}
/**
 * Scene transition options
 */
interface SceneTransitionOptions {
    /** Transition duration in milliseconds */
    duration?: number;
    /** Transition type */
    type?: "fade" | "slide" | "none";
}
/**
 * Scene configuration
 */
interface SceneConfig {
    /** Default scene name */
    defaultScene?: string;
    /** Enable history management */
    enableHistory?: boolean;
    /** Scene transition options */
    transition?: SceneTransitionOptions;
}
/**
 * Scene events
 */
interface SceneEvents {
    /** Event emitted when scene is activated */
    onActivate?: (name: string, params?: Record<string, string>) => void;
    /** Event emitted when scene is deactivated */
    onDeactivate?: (name: string) => void;
}
/**
 * Scene interface for VM (Virtual Machine)
 * This is what gets exposed to lootiscript as `scene`
 */
interface SceneInterface {
    register: (name: string, def: SceneDefinition) => void;
    route: (path: string, sceneName: string) => void;
    goto: (name: string, params?: Record<string, string>) => void;
    current: () => string | null;
}

declare class SceneRegistry {
    private scenes;
    /**
     * Register a new scene
     */
    register(name: string, definition: SceneDefinition): void;
    /**
     * Get a scene definition
     */
    get(name: string): SceneDefinition | undefined;
    /**
     * Check if scene exists
     */
    has(name: string): boolean;
    /**
     * Get all registered scene names
     */
    getNames(): string[];
    /**
     * Clear all scenes
     */
    clear(): void;
}

declare class SceneManager {
    readonly registry: SceneRegistry;
    readonly routeManager: RouteManager;
    readonly router: Router;
    private activeSceneName;
    private activeScene;
    constructor();
    /**
     * Register a scene
     * @param name Unique name for the scene
     * @param definition Scene definition object with lifecycle methods
     */
    registerScene(name: string, definition: SceneDefinition): void;
    /**
     * Validate scene registration inputs
     */
    private validateSceneRegistration;
    /**
     * Register a route
     */
    registerRoute(path: string, sceneName: string): void;
    /**
     * Set active scene
     * @param name Name of the scene to activate
     * @param params Route parameters to pass to onEnter
     */
    setActiveScene(name: string, params?: Record<string, string>): void;
    /**
     * Handle scene not found error
     */
    private handleSceneNotFound;
    /**
     * Check if scene is already active
     */
    private isSameScene;
    /**
     * Handle activation of already active scene
     */
    private handleSameSceneActivation;
    /**
     * Transition from current scene to new scene
     */
    private transitionToScene;
    /**
     * Leave current scene
     */
    private leaveCurrentScene;
    /**
     * Activate new scene
     */
    private activateNewScene;
    /**
     * Initialize scene if not already initialized
     */
    private initializeSceneIfNeeded;
    /**
     * Enter scene (call onEnter lifecycle method)
     */
    private enterScene;
    /**
     * Update active scene (called every frame)
     */
    update(): void;
    /**
     * Draw active scene (called every frame)
     */
    draw(): void;
    /**
     * Check if there is an active scene
     */
    hasActiveScene(): boolean;
    /**
     * Get current active scene name
     * @returns Name of currently active scene, or null if none
     */
    getCurrentSceneName(): string | null;
    /**
     * Get current active scene definition
     * @returns Currently active scene definition, or null if none
     */
    getCurrentScene(): SceneDefinition | null;
    /**
     * Get public API interface for VM
     */
    getInterface(): any;
}

declare class Router {
    private routeManager;
    private sceneManager;
    private state;
    constructor(routeManager: RouteManager, sceneManager: SceneManager);
    /**
     * Setup browser history listener
     */
    private setupPopStateListener;
    /**
     * Navigate to a path (adds to browser history)
     * @param path Path to navigate to (e.g., "/player/42")
     */
    push(path: string): void;
    /**
     * Replace current path (doesn't add to browser history)
     * @param path Path to navigate to (e.g., "/player/42")
     */
    replace(path: string): void;
    /**
     * Go back in browser history
     */
    back(): void;
    /**
     * Get current state (returns a copy to prevent mutation)
     */
    getState(): RouterState;
    /**
     * Validate path input
     */
    private validatePath;
    /**
     * Update browser history
     */
    private updateBrowserHistory;
    /**
     * Handle path change
     * @param path Path to match against routes
     */
    private handlePathChange;
    /**
     * Update state when route matches
     */
    private updateStateWithMatch;
    /**
     * Handle case when no route matches
     */
    private handleNoRouteMatch;
    /**
     * Activate first available scene as fallback
     */
    private activateFirstAvailableScene;
    /**
     * Initialize router with current window path
     * Should be called after routes are registered but before game loop starts
     */
    init(): void;
    /**
     * Ensure at least one scene is active after initialization
     */
    private ensureActiveScene;
    /**
     * Get public API interface for VM
     * This is what gets exposed to lootiscript as `router`
     * Note: VM may not support getters properly, so we use both functions and properties
     */
    getInterface(): any;
}

export { type RouteDefinition, RouteManager, Router, type RouterState, type SceneConfig, type SceneData, type SceneDefinition, type SceneEvents, type SceneInterface, SceneManager, type SceneManagerOptions, SceneRegistry, type SceneStatus, type SceneTransitionOptions };