/**
 * @module viw-webgl-viewer/camera
 */
import * as THREE from 'three';
import { ISignal } from 'ste-signals';
import { RenderScene } from '../rendering/renderScene';
import { ViewerSettings } from '../settings/viewerSettings';
import { Viewport } from '../viewport';
import { ICamera } from './cameraInterface';
import { CameraMovement } from './cameraMovement';
import { OrthographicCamera } from './cameraOrthographic';
import { PerspectiveCamera } from './cameraPerspective';
/**
 * Manages viewer camera movement and position
 */
export declare class Camera implements ICamera {
    camPerspective: PerspectiveCamera;
    camOrthographic: OrthographicCamera;
    private _viewport;
    private _scene;
    private _lerp;
    private _movement;
    private _inputVelocity;
    private _velocity;
    private _orthographic;
    private _target;
    private _lastPosition;
    private _lastQuaternion;
    private _lastTarget;
    private _tmp1;
    private _tmp2;
    private _savedState;
    /**
     * A signal that is dispatched when camera settings change.
     */
    get onSettingsChanged(): ISignal;
    private _onValueChanged;
    /**
     * True if the camera has moved this frame.
     */
    get hasMoved(): boolean;
    private _hasMoved;
    get isLerping(): boolean;
    /**
     * A signal that is dispatched when the camera is moved.
     */
    get onMoved(): ISignal;
    private _onMoved;
    /** Ignore movement permissions when true */
    private _force;
    /**
     * Represents allowed movement along each axis using a Vector3 object.
     * Each component of the Vector3 should be either 0 or 1 to enable/disable movement along the corresponding axis.
     */
    private _allowedMovement;
    get allowedMovement(): THREE.Vector3;
    set allowedMovement(axes: THREE.Vector3);
    /**
     * Represents allowed rotation using a Vector2 object.
     * Each component of the Vector2 should be either 0 or 1 to enable/disable rotation around the corresponding axis.
     */
    get allowedRotation(): THREE.Vector2;
    set allowedRotation(axes: THREE.Vector2);
    private _allowedRotation;
    /**
     * The default forward direction that can be used to initialize the camera.
     */
    private _defaultForward;
    get defaultForward(): THREE.Vector3;
    set defaultForward(value: THREE.Vector3);
    private _velocityBlendFactor;
    constructor(scene: RenderScene, viewport: Viewport, settings: ViewerSettings);
    /**
     * Interface for instantaneously moving the camera.
     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
     * @returns {CameraMovement} The camera movement api.
     */
    snap(force?: boolean): CameraMovement;
    /**
     * Interface for smoothly moving the camera over time.
     * @param {number} [duration=1] - The duration of the camera movement animation.
     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
     * @returns {CameraMovement} The camera movement api.
     */
    lerp(duration?: number, force?: boolean): CameraMovement;
    /**
     * Calculates the frustum size at a given point in the scene.
     * @param {THREE.Vector3} point - The point in the scene to calculate the frustum size at.
     * @returns {number} The frustum size at the specified point.
     */
    frustrumSizeAt(point: THREE.Vector3): THREE.Vector2;
    /**
     * The current THREE Camera
     */
    get three(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
    /**
     * The quaternion representing the orientation of the object.
     */
    get quaternion(): THREE.Quaternion;
    /**
     * The position of the camera.
     */
    get position(): THREE.Vector3;
    /**
     * The matrix representing the transformation of the camera.
     */
    get matrix(): THREE.Matrix4;
    /**
     * The forward direction of the camera.
     */
    get forward(): THREE.Vector3;
    /**
     * The current or target velocity of the camera.
     */
    get localVelocity(): THREE.Vector3;
    /**
     * The current or target velocity of the camera.
     */
    set localVelocity(vector: THREE.Vector3);
    /**
     * Immediately stops the camera movement.
     */
    stop(): void;
    /**
     * The target at which the camera is looking at and around which it rotates.
     */
    get target(): THREE.Vector3;
    private applySettings;
    /**
     * The distance from the camera to the target.
     */
    get orbitDistance(): number;
    /**
     * Saves current camera orientation to restore on next reset.
     */
    save(): void;
    /**
     * Represents whether the camera projection is orthographic.
     */
    get orthographic(): boolean;
    set orthographic(value: boolean);
    update(deltaTime: number): boolean;
    private updateProjection;
    private updateOrthographic;
    private applyVelocity;
    private getVelocityMultiplier;
    private checkForMovement;
    private applyVelocityOrthographic;
}
