import { Scene } from '@babylonjs/core';
import { ClusteredLightContainer } from '@babylonjs/core/Lights/Clustered/clusteredLightContainer';
import { LoggerInterface } from "../interfaces/logger.d.ts";
import { LevelConfig, LevelContext, LevelInstance, PropertyHandler } from "../interfaces/level.d.ts";
import { GameEngine } from "./gameEngine.d.ts";
import { OutlineManager } from "../managers/outline.d.ts";
/**
 * Abstract base class for game levels.
 *
 * Levels are responsible for creating and configuring their own scenes via the
 * `buildScene()` method. All runtime dependencies (eventBus, sceneEngine, entityManager)
 * are injected via the constructor and are immediately available.
 *
 * Users should not instantiate Level subclasses directly. Instead, use LevelManager
 * which acts as a factory and injects the required dependencies:
 *
 * ```typescript
 * // Register a custom level class
 * levelManager.registerLevelClass('my-level', MyCustomLevel);
 *
 * // Load the level - manager creates instance with deps injected
 * const level = await levelManager.loadLevel({ name: 'Level1', class: 'my-level' });
 * ```
 */
export declare abstract class Level implements LevelInstance {
    readonly name: string;
    protected readonly _log: LoggerInterface;
    protected readonly _context: LevelContext;
    protected _scene: Scene | null;
    clusteredLights: ClusteredLightContainer | null;
    outlines: OutlineManager | null;
    /**
     * Creates a new Level instance.
     *
     * @param config
     * @param context
     */
    constructor(config: LevelConfig, context: LevelContext);
    get scene(): Scene | null;
    get isLoaded(): boolean;
    get gameEngine(): GameEngine;
    get propertyHandlers(): Map<string, PropertyHandler>;
    /**
     * Emit a progress event during loading
     *
     * @param progress - Percentage (0-100)
     * @param message
     */
    protected $emitProgress(progress: number, message: string): void;
    /**
     * Load and create the scene for this level.
     * Progress events will be emitted during loading.
     */
    load(): Promise<Scene>;
    /**
     * Abstract method for building the scene content.
     * Concrete levels must implement this to create their specific content.
     *
     * All dependencies are available via `this.gameEngine`.
     *
     */
    protected abstract buildScene(): Promise<Scene>;
    /**
     * Called when this level becomes the active level during a transition.
     * Override in subclasses to perform activation logic (e.g., start music, show UI).
     * Default implementation is a no-op.
     */
    onActivate?(): Promise<void> | void;
    /**
     * Called when this level is being replaced during a transition.
     * Override in subclasses to perform cleanup logic (e.g., fade out, save state).
     * Default implementation is a no-op.
     */
    onDeactivate?(): Promise<void> | void;
    /**
     * Dispose of this level's resources and scene.
     *
     * The `$` prefix indicates this is an internal lifecycle method, consistent with
     * other engine lifecycle methods like `$teardown()`.
     */
    $dispose(): Promise<void>;
}