/**
 * Screen/State management for ECSpresso ECS framework
 */
import type EventBus from './event-bus';
import type { ScreenDefinition, ScreenResource, ScreenEvents, ScreenConfigurator, ScreenConfig, ScreenState } from './screen-types';
/** Structural interface covering only the AssetManager methods ScreenManager uses. */
interface ScreenManagerAssetDeps {
    isLoaded(key: string): boolean;
    loadAsset(key: string): Promise<unknown>;
    isGroupLoaded(group: string): boolean;
    loadAssetGroup(group: string): Promise<void>;
}
/**
 * Manages screen/state transitions for ECSpresso
 */
export default class ScreenManager<Screens extends Record<string, ScreenDefinition<any, any>> = Record<string, never>> {
    private readonly screens;
    private currentScreen;
    private screenStack;
    private eventBus;
    private assetManager;
    private ecs;
    private closed;
    private readonly pendingHooks;
    private readonly teardownErrors;
    private readonly exitedScreens;
    /** Register before invoking user code, which may synchronously start teardown. */
    private runHook;
    /**
     * Set dependencies for screen transitions
     * @internal
     */
    setDependencies(eventBus: EventBus<ScreenEvents<keyof Screens & string>>, assetManager: ScreenManagerAssetDeps | null, ecs: unknown): void;
    private requireEcs;
    /**
     * Register a screen definition
     */
    register<K extends string, Config extends Record<string, unknown>, State extends Record<string, unknown>>(name: K, definition: ScreenDefinition<Config, State>): void;
    /**
     * Transition to a new screen, clearing the stack
     */
    setScreen<K extends keyof Screens>(name: K, config: Screens[K] extends ScreenDefinition<infer C, any> ? C : never): Promise<void>;
    /**
     * Push a screen onto the stack (overlay)
     */
    pushScreen<K extends keyof Screens>(name: K, config: Screens[K] extends ScreenDefinition<infer C, any> ? C : never): Promise<void>;
    /**
     * Pop the current screen and return to the previous one
     */
    popScreen(): Promise<void>;
    /**
     * Exit an activation once, including when teardown overlaps a transition.
     */
    private exitScreen;
    /**
     * Verify required assets are loaded before screen transition
     */
    private verifyRequiredAssets;
    /**
     * Get the current screen name
     */
    getCurrentScreen(): keyof Screens | null;
    /**
     * Get the current screen config (immutable).
     * If `screen` is provided, asserts that the current screen matches.
     */
    getConfig(screen?: keyof Screens): Readonly<ScreenConfig<Screens[keyof Screens]>>;
    /**
     * Get the current screen config or undefined.
     * If `screen` is provided, returns undefined when the current screen doesn't match.
     */
    tryGetConfig(screen?: keyof Screens): Readonly<ScreenConfig<Screens[keyof Screens]>> | undefined;
    /**
     * Get the current screen state (mutable).
     * If `screen` is provided, asserts that the current screen matches.
     */
    getState(screen?: keyof Screens): ScreenState<Screens[keyof Screens]>;
    /**
     * Get the current screen state or undefined.
     * If `screen` is provided, returns undefined when the current screen doesn't match.
     */
    tryGetState(screen?: keyof Screens): ScreenState<Screens[keyof Screens]> | undefined;
    /**
     * Update the current screen state.
     * If `screen` is provided, asserts that the current screen matches.
     */
    updateState(update: unknown, screen?: keyof Screens): void;
    /**
     * Get the screen stack depth
     */
    getStackDepth(): number;
    /**
     * Check if current screen is an overlay
     */
    isOverlay(): boolean;
    /**
     * Check if a screen is active (current or in stack)
     */
    isActive(screenName: keyof Screens): boolean;
    /**
     * Check if a screen is the current screen
     */
    isCurrent(screenName: keyof Screens): boolean;
    /**
     * Create the $screen resource object
     */
    createResource(): ScreenResource<Screens>;
    /**
     * Get all registered screen names
     */
    getScreenNames(): Array<keyof Screens>;
    /**
     * Check if a screen is registered
     */
    hasScreen(name: keyof Screens): boolean;
    /** @internal Stop transitions while the enclosing world is disposing. */
    close(): void;
    /**
     * Exit active screens during enclosing-world disposal. Screen-exit events are
     * best-effort here because the world event bus is already closed; the world
     * separately removes all entities and screen-scope registrations.
     */
    dispose(): Promise<void>;
    /** @internal Release screen definitions, active state, and world references. */
    clear(): void;
}
/**
 * Implementation of ScreenConfigurator for builder pattern
 */
export declare class ScreenConfiguratorImpl<Screens extends Record<string, ScreenDefinition<any, any>>, W = unknown> implements ScreenConfigurator<Screens, W> {
    private readonly manager;
    constructor(manager: ScreenManager<Screens>);
    add<K extends string, Config extends Record<string, unknown>, State extends Record<string, unknown>>(name: K, definition: ScreenDefinition<Config, State, W>): ScreenConfigurator<Screens & Record<K, ScreenDefinition<Config, State, W>>, W>;
    /**
     * Get the underlying manager
     * @internal
     */
    getManager(): ScreenManager<Screens>;
}
/**
 * Create a new ScreenConfigurator for builder pattern usage
 */
export declare function createScreenConfigurator<Screens extends Record<string, ScreenDefinition<any, any>> = Record<string, never>, W = unknown>(manager?: ScreenManager<Screens>): ScreenConfiguratorImpl<Screens, W>;
export {};