import type { EngineOptions } from "@babylonjs/core/Engines/thinEngine.js";
import { type SceneDocumentData, type RuntimeBackendSnapshot, type RuntimeProbeReport, type GpuProgramCacheSnapshot } from "@skenora/contracts";
import type { ResourceResolver } from "@skenora/resources";
import { type LoadDocumentOptions, type RuntimeExecutionMode } from "../core/runtime-session.js";
import type { ModelViewerControlOptions } from "../systems/camera-controller.js";
export type { ModelViewerControlOptions } from "../systems/camera-controller.js";
export interface SceneRendererOptions {
    antialias?: boolean;
    engineOptions?: EngineOptions;
    /** Defaults to true for presentation-quality output. */
    adaptToDeviceRatio?: boolean;
    autoResize?: boolean;
    /** Defaults to authoring so presentation facades never run scene behavior. */
    executionMode?: RuntimeExecutionMode;
    onStatusListenerError?: (error: unknown) => void;
}
export type SceneCameraView = "front" | "back" | "left" | "right" | "top" | "bottom" | "perspective";
export type SceneRendererStatus = "idle" | "loading" | "ready" | "error" | "disposed";
export type SceneRendererStatusListener = (status: SceneRendererStatus, error: unknown | null) => void;
export interface SceneCaptureRegion {
    x: number;
    y: number;
    width: number;
    height: number;
}
export interface SceneCaptureOptions {
    signal?: AbortSignal;
    width?: number;
    height?: number;
    type?: string;
    quality?: number;
    transparent?: boolean;
    /** Pixel coordinates in the rendered capture, before output encoding. */
    crop?: SceneCaptureRegion;
}
export interface SceneCaptureBatchOptions extends SceneCaptureOptions {
    /** Defaults to front, right, top and perspective; at most seven images. */
    views?: readonly SceneCameraView[];
}
export interface SceneViewCapture {
    view: SceneCameraView;
    documentId: string;
    loadGeneration: number;
    blob: Blob;
}
export interface SceneModelLoadFailure {
    entityId: string;
    error: unknown;
}
/**
 * Read-only presentation facade over RuntimeSession.
 *
 * It intentionally does not expose the Babylon scene, nodes, document
 * projection methods, extensions, or any document capture operation.
 */
export declare class SceneRenderer {
    #private;
    constructor(canvas: HTMLCanvasElement, options?: SceneRendererOptions);
    get canvas(): HTMLCanvasElement;
    get rendering(): boolean;
    get documentId(): string | null;
    get status(): SceneRendererStatus;
    get error(): unknown | null;
    get modelFailures(): readonly SceneModelLoadFailure[];
    getBackendSnapshot(): RuntimeBackendSnapshot;
    sampleSceneCost(options?: import("@skenora/contracts").SceneCostSamplingOptions): Promise<import("@skenora/contracts").SceneCostReport>;
    getGpuProgramCacheSnapshot(): GpuProgramCacheSnapshot;
    /** Serializes with capture so render/readback operations never overlap. */
    probe(): Promise<RuntimeProbeReport>;
    subscribeStatus(listener: SceneRendererStatusListener, options?: {
        signal?: AbortSignal;
        immediate?: boolean;
    }): () => void;
    load(document: Readonly<SceneDocumentData>, resources: ResourceResolver, options?: LoadDocumentOptions): Promise<void>;
    frame(): void;
    setView(view: SceneCameraView): void;
    focus(options?: import("@skenora/contracts").SceneFocusOptions): Promise<import("@skenora/contracts").SceneFocusResult>;
    resetView(view?: SceneCameraView): void;
    captureView(): import("@skenora/contracts").SceneViewState;
    restoreView(state: import("@skenora/contracts").SceneViewState): void;
    cancelFocus(): void;
    configureViewerControls(options?: ModelViewerControlOptions): void;
    normalizeModelView(view?: SceneCameraView): void;
    resize(): void;
    pause(): void;
    resume(): void;
    setAutoRotate(enabled: boolean, speed?: number): void;
    capture(options?: SceneCaptureOptions): Promise<Blob>;
    getModelInformation(entityId?: string, options?: import("@skenora/contracts").ModelInformationOptions): import("@skenora/contracts").LoadedModelInformation | null;
    framePart(entityId: string, partId: string, projectionGeneration: number): void;
    captureViews(options?: SceneCaptureBatchOptions): Promise<SceneViewCapture[]>;
    dispose(): void;
}
//# sourceMappingURL=scene-renderer.d.ts.map