import type { Material } from "@babylonjs/core/Materials/material.js";
import type { Node } from "@babylonjs/core/node.js";
import type { MaterialRuntimeProperty, MaterialAnimationPlayOptions, MaterialAnimationResult, MaterialAnimationState, TransformUpdate, SceneAnimationTracks, SceneAnimationClips, SceneFocusOptions, SceneFocusResult, CapabilityDescription, CapabilityAvailability } from "@skenora/contracts";
import type { CameraPathPlaybackOptions, CameraPathPlaybackState } from "../systems/camera-path-controller.js";
export declare const RUNTIME_NODES_CAPABILITY = "runtime.nodes";
export declare const RUNTIME_LOOP_CAPABILITY = "runtime.loop";
export declare const RUNTIME_SERVICE_CONTROL_CAPABILITY = "runtime.services";
export declare const RUNTIME_TRANSFORMS_CAPABILITY = "runtime.transforms";
export declare const RUNTIME_TRANSIENTS_CAPABILITY = "runtime.transients";
export declare const RUNTIME_MATERIALS_CAPABILITY = "runtime.materials";
export declare const RUNTIME_MATERIAL_ANIMATIONS_CAPABILITY = "runtime.material-animations";
export declare const RUNTIME_SCENE_ANIMATION_TRACKS_CAPABILITY = "runtime.scene-animation-tracks";
export declare const RUNTIME_SCENE_ANIMATION_CLIPS_CAPABILITY = "runtime.scene-animation-clips";
export declare const RUNTIME_CAMERA_CAPABILITY = "runtime.camera";
export declare const RUNTIME_ANIMATIONS_CAPABILITY = "runtime.animations";
export declare const RUNTIME_PARTICLES_CAPABILITY = "runtime.particles";
export declare const RUNTIME_TEXTURE_ANIMATIONS_CAPABILITY = "runtime.texture-animations";
export interface RuntimeEntityState {
    id: string;
    enabled: boolean;
    visible: boolean;
    transform?: TransformUpdate;
}
export interface RuntimeNodeCapability {
    get(entityId: string): Node | null;
    require(entityId: string): Node;
    getState(entityId: string): RuntimeEntityState | null;
    setEnabled(entityId: string, enabled: boolean): void;
    setVisible(entityId: string, visible: boolean): void;
    setTransform(entityId: string, transform: TransformUpdate): void;
    setTransparent(entityId: string, alpha: number | null): void;
    setOutline(entityId: string, color: string | null): void;
}
export interface RuntimeMaterialCapability {
    get(materialId: string): Material | null;
    setProperty(materialId: string, property: MaterialRuntimeProperty, value: unknown): void;
}
export interface RuntimeMaterialAnimationCapability {
    play(materialId: string, animationId: string, options?: MaterialAnimationPlayOptions): Promise<MaterialAnimationResult>;
    pause(materialId: string, animationId: string): boolean;
    resume(materialId: string, animationId: string): boolean;
    stop(materialId: string, animationId: string): void;
    reset(materialId: string, animationId: string): void;
    getState(materialId: string, animationId: string): MaterialAnimationState | null;
}
export interface RuntimeCameraCapability {
    frame(entityIds?: readonly string[]): void;
    focus(entityIds?: readonly string[], options?: SceneFocusOptions): Promise<SceneFocusResult>;
    activateEntity(entityId: string, controls?: boolean): boolean;
    restoreViewport(): void;
    playPath(pathId: string, options?: CameraPathPlaybackOptions): Promise<void>;
    validatePath(pathId: string, options?: CameraPathPlaybackOptions): void;
    pausePath(): boolean;
    resumePath(): boolean;
    stopPath(): void;
    getPathState(): CameraPathPlaybackState;
    subscribePath(listener: (state: CameraPathPlaybackState) => void): () => void;
}
export interface RuntimeAnimationObserver {
    started?(animation: string): void;
    completed?(animation: string): void;
}
export interface RuntimeAnimationCapability {
    play(entityId: string, animation?: string | null, observer?: RuntimeAnimationObserver, options?: import("@skenora/contracts").ImportedAnimationPlayOptions): readonly string[];
    stop(entityId: string, animation?: string | null): void;
}
export interface RuntimeParticleCapability {
    setRunning(entityId: string, running: boolean): boolean;
    cloud?: {
        getState(entityId: string): import("@skenora/contracts").ParticleCloudState | null;
        setFrame(entityId: string, frame: import("@skenora/contracts").ParticleCloudFrame): boolean;
        reset(entityId: string): boolean;
    };
}
export interface RuntimeTextureAnimationCapability {
    play(animationId: string, options?: {
        signal?: AbortSignal;
    }): Promise<void>;
    stop(animationId: string): void;
}
/**
 * Open capability map. Runtime extensions may augment this interface through
 * TypeScript module augmentation and register their own named capabilities.
 */
export interface RuntimeCapabilityMap {
    [RUNTIME_LOOP_CAPABILITY]: import("../systems/runtime-loop.js").RuntimeLoop;
    [RUNTIME_SERVICE_CONTROL_CAPABILITY]: import("../systems/runtime-service-registry.js").RuntimeServiceRegistry;
    [RUNTIME_TRANSFORMS_CAPABILITY]: {
        acquire(options: import("../systems/runtime-transform-leases.js").RuntimeTransformLeaseOptions): import("../systems/runtime-transform-leases.js").RuntimeTransformWriteLease;
    };
    [RUNTIME_TRANSIENTS_CAPABILITY]: import("../systems/runtime-transient-entities.js").RuntimeTransientCapability;
    [RUNTIME_SCENE_ANIMATION_TRACKS_CAPABILITY]: SceneAnimationTracks;
    [RUNTIME_SCENE_ANIMATION_CLIPS_CAPABILITY]: SceneAnimationClips;
    [RUNTIME_NODES_CAPABILITY]: RuntimeNodeCapability;
    [RUNTIME_MATERIALS_CAPABILITY]: RuntimeMaterialCapability;
    [RUNTIME_MATERIAL_ANIMATIONS_CAPABILITY]: RuntimeMaterialAnimationCapability;
    [RUNTIME_CAMERA_CAPABILITY]: RuntimeCameraCapability;
    [RUNTIME_ANIMATIONS_CAPABILITY]: RuntimeAnimationCapability;
    [RUNTIME_PARTICLES_CAPABILITY]: RuntimeParticleCapability;
    [RUNTIME_TEXTURE_ANIMATIONS_CAPABILITY]: RuntimeTextureAnimationCapability;
}
export declare class RuntimeCapabilityRegistry {
    #private;
    register<TKey extends keyof RuntimeCapabilityMap>(id: TKey, capability: RuntimeCapabilityMap[TKey], metadata?: {
        description: CapabilityDescription;
        observe?: () => CapabilityAvailability;
    }): () => void;
    replace<TKey extends keyof RuntimeCapabilityMap>(id: TKey, capability: RuntimeCapabilityMap[TKey]): RuntimeCapabilityMap[TKey] | null;
    get<TKey extends keyof RuntimeCapabilityMap>(id: TKey): RuntimeCapabilityMap[TKey] | null;
    require<TKey extends keyof RuntimeCapabilityMap>(id: TKey): RuntimeCapabilityMap[TKey];
    has(id: keyof RuntimeCapabilityMap): boolean;
    getDescriptions(): readonly CapabilityDescription[];
    getAvailability(): readonly CapabilityAvailability[];
    clear(): void;
}
//# sourceMappingURL=runtime-capability-registry.d.ts.map