import * as THREE from "three";
import { Copper3dTrackballControls } from "../Controls/Copper3dTrackballControls";
import { CameraViewPoint } from "../Controls/copperControls";
import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
import { baseScene } from "./baseScene";
import { vtkModels } from "../types/types";
import { TrackballControls } from "three/examples/jsm/controls/TrackballControls";
import { ICopperSceneOpts, aligned4DOptsType, Aligned4DController, raw4DVolumeOptsType, Raw4DVolumeController } from "../types/types";
import { SurfaceAnnotator } from "../Utils/surfaceAnnotation";
import type { SurfaceAnnotatorOptions } from "../Utils/surfaceAnnotation";
export declare class copperScene extends baseScene {
    clock: THREE.Clock;
    controls: Copper3dTrackballControls | OrbitControls | TrackballControls;
    private mixer;
    private playRate;
    private modelReady;
    private clipAction;
    private surfaceAnnotators;
    constructor(container: HTMLDivElement, renderer: THREE.WebGLRenderer, opt?: ICopperSceneOpts);
    loadGltf(url: string, callback?: (content: THREE.Group) => void): void;
    loadPureGLB(url: string, callback?: (mesh: THREE.Group) => void, opts?: {
        color: string;
        enhanceMaterial?: boolean;
    }, onError?: (error: unknown) => void): void;
    loadVtk(url: string): void;
    /**
     * Create an annotator on the surface of a given model (draw contours / place points / export coordinates).
     * target can be a single Mesh, or a Group/Object3D (the mesh with the most vertices is chosen automatically).
     * Reuses this scene's camera / container / controls; non-indexed geometry is welded and indexed automatically.
     */
    createSurfaceAnnotator(target: THREE.Mesh | THREE.Object3D, opts?: Omit<SurfaceAnnotatorOptions, "scene" | "camera" | "container" | "controls" | "mesh">): SurfaceAnnotator;
    private pickAnnotatableMesh;
    /** Dispose all annotators created on this scene (removes event listeners and annotation objects). */
    disposeSurfaceAnnotators(): void;
    loadVtks(models: Array<vtkModels>): void;
    /**
     * Load an aligned 4D scene: a cine MRI (one slice, N cardiac phases) rendered as a
     * world-placed plane, plus 0..N deforming surface sequences (e.g. LV endo/epi). MRI
     * and surfaces stay in their shared patient coordinate frame (no center/scale), and
     * advance together off ONE shared frame clock. Returns a controller (play/pause/...).
     */
    loadAligned4D(opts: aligned4DOptsType, callback?: (ctrl: Aligned4DController) => void): void;
    /**
     * Load a 4D volume sequence (.mhd/.raw per cardiac phase) and render it as a raycast
     * volume. The returned controller runs no clock of its own — drive it with
     * setFrame()/setPhase() so it can share a cardiac-phase clock with other modalities.
     */
    loadRaw4DVolume(mhdUrls: Array<string>, opts?: raw4DVolumeOptsType, callback?: (ctrl: Raw4DVolumeController) => void): void;
    getPlayRate(): number;
    setPlayRate(playRate: number): void;
    setModelPosition(model: THREE.Group | THREE.Mesh, position: {
        x?: number;
        y?: number;
        z?: number;
    }): void;
    loadView(viewpointData: CameraViewPoint): void;
    resetView(): void;
    updateCamera(viewpoint: CameraViewPoint): void;
    getCurrentTime(): number;
    getCurrentMixer(): THREE.AnimationMixer<THREE.AnimationMixerEventMap> | null;
    updateControls(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
    onRenderCameraChange(): void;
    render(time?: number): void;
}