import { SettingsEngine } from "@shapediver/viewer.shared.services";
import { type ICameraOptions } from "@shapediver/viewer.shared.types";
import { mat4, vec2, vec3 } from "gl-matrix";
import { type ICamera } from "../../interfaces/camera/ICamera";
import { type ICameraControls } from "../../interfaces/controls/ICameraControls";
import { type ICameraControlsEventDistribution } from "../../interfaces/controls/ICameraControlsEventDistribution";
import { type ICameraControlsLogic } from "../../interfaces/controls/ICameraControlsLogic";
export declare abstract class AbstractCameraControls implements ICameraControls {
    private _camera;
    private _enabled;
    private readonly _cameraInterpolationManager;
    private readonly _converter;
    private readonly _eventEngine;
    private _autoRotationSpeed;
    private _canvas?;
    private _cubePositionRestriction;
    private _cubeTargetRestriction;
    private _damping;
    private _enableAutoRotation;
    private _enableAzimuthRotation;
    private _enableKeyPan;
    private _enableObjectControls;
    private _enablePan;
    private _enablePolarRotation;
    private _enableRotation;
    private _enableTurntableControls;
    private _enableZoom;
    private _input;
    private _keyPanSpeed;
    private _manualInteraction;
    private _manualInteractionTransformations;
    private _movementSmoothness;
    private _moving;
    private _movingDuration;
    private _nonmanualInteraction;
    private _nonmanualInteractionTransformations;
    private _objectControlsCenter;
    private _panSpeed;
    private _position;
    private _rotationRestriction;
    private _rotationSpeed;
    private _sceneRotation;
    private _spherePositionRestriction;
    private _sphereTargetRestriction;
    private _target;
    private _turntableCenter;
    private _viewportId?;
    private _zoomRestriction;
    private _zoomSpeed;
    protected _cameraControlsEventDistribution: ICameraControlsEventDistribution;
    protected _cameraLogic: ICameraControlsLogic;
    constructor(_camera: ICamera, _enabled: boolean);
    get autoRotationSpeed(): number;
    set autoRotationSpeed(value: number);
    get camera(): ICamera;
    set camera(value: ICamera);
    get cameraControlsEventDistribution(): ICameraControlsEventDistribution;
    get canvas(): HTMLCanvasElement | undefined;
    set canvas(value: HTMLCanvasElement | undefined);
    get cubePositionRestriction(): {
        min: vec3;
        max: vec3;
    };
    set cubePositionRestriction(value: {
        min: vec3;
        max: vec3;
    });
    get cubeTargetRestriction(): {
        min: vec3;
        max: vec3;
    };
    set cubeTargetRestriction(value: {
        min: vec3;
        max: vec3;
    });
    get damping(): number;
    set damping(value: number);
    get enableAutoRotation(): boolean;
    set enableAutoRotation(value: boolean);
    get enableAzimuthRotation(): boolean;
    set enableAzimuthRotation(value: boolean);
    get enableKeyPan(): boolean;
    set enableKeyPan(value: boolean);
    get enableObjectControls(): boolean;
    set enableObjectControls(value: boolean);
    get enablePan(): boolean;
    set enablePan(value: boolean);
    get enablePolarRotation(): boolean;
    set enablePolarRotation(value: boolean);
    get enableRotation(): boolean;
    set enableRotation(value: boolean);
    get enableTurntableControls(): boolean;
    set enableTurntableControls(value: boolean);
    get enableZoom(): boolean;
    set enableZoom(value: boolean);
    get enabled(): boolean;
    set enabled(value: boolean);
    get input(): {
        keys: {
            up: number;
            down: number;
            left: number;
            right: number;
        };
        mouse: {
            rotate: number;
            zoom: number;
            pan: number;
        };
        touch: {
            rotate: number;
            zoom: number;
            pan: number;
        };
    };
    set input(value: {
        keys: {
            up: number;
            down: number;
            left: number;
            right: number;
        };
        mouse: {
            rotate: number;
            zoom: number;
            pan: number;
        };
        touch: {
            rotate: number;
            zoom: number;
            pan: number;
        };
    });
    get keyPanSpeed(): number;
    set keyPanSpeed(value: number);
    get movementSmoothness(): number;
    set movementSmoothness(value: number);
    get objectControlsCenter(): vec3;
    set objectControlsCenter(value: vec3);
    get panSpeed(): number;
    set panSpeed(value: number);
    get position(): vec3;
    set position(value: vec3);
    get rotationRestriction(): {
        minPolarAngle: number;
        maxPolarAngle: number;
        minAzimuthAngle: number;
        maxAzimuthAngle: number;
    };
    set rotationRestriction(value: {
        minPolarAngle: number;
        maxPolarAngle: number;
        minAzimuthAngle: number;
        maxAzimuthAngle: number;
    });
    get rotationSpeed(): number;
    set rotationSpeed(value: number);
    get sceneRotation(): vec2;
    set sceneRotation(value: vec2);
    get spherePositionRestriction(): {
        center: vec3;
        radius: number;
    };
    set spherePositionRestriction(value: {
        center: vec3;
        radius: number;
    });
    get sphereTargetRestriction(): {
        center: vec3;
        radius: number;
    };
    set sphereTargetRestriction(value: {
        center: vec3;
        radius: number;
    });
    get target(): vec3;
    set target(value: vec3);
    get turntableCenter(): vec3;
    set turntableCenter(value: vec3);
    get zoomRestriction(): {
        minDistance: number;
        maxDistance: number;
    };
    set zoomRestriction(value: {
        minDistance: number;
        maxDistance: number;
    });
    get zoomSpeed(): number;
    set zoomSpeed(value: number);
    animate(path: {
        position: vec3;
        target: vec3;
    }[], options: ICameraOptions): Promise<boolean>;
    applyPositionMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void;
    applyPositionVector(vector: vec3, manualInteraction?: boolean | undefined): void;
    applyRotation(vector: vec2, manualInteraction?: boolean | undefined): void;
    applySettings(settingsEngine: SettingsEngine): void;
    applyTargetMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void;
    applyTargetVector(vector: vec3, manualInteraction?: boolean | undefined): void;
    applyUpMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void;
    assignViewer(viewportId: string, canvas: HTMLCanvasElement): void;
    pauseAnimation(): () => void;
    getPositionWithManualUpdates(): vec3;
    getPositionWithUpdates(): vec3;
    getTargetWithManualUpdates(): vec3;
    getTargetWithUpdates(): vec3;
    isMoving(): boolean;
    isWithinRestrictions(position: vec3, target: vec3): boolean;
    reset(): void;
    update(time: number): {
        position: vec3;
        target: vec3;
        sceneRotation: vec2;
    };
    private getPosition;
    private getSceneRotation;
    private getTarget;
}
//# sourceMappingURL=AbstractCameraControls.d.ts.map