import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
import CameraControls from '../library/camera-controls';
import Store from './Store';
import { IControlOption } from '../../model/IControlOption';
import { IControl } from '../../model/common/IControl';
import { IVector2 } from '../../model/common/IVector2';
import { IVector3 } from '../../model/common/IVector3';
import { IDimension } from '../../model/common/IDimension';
import { IFitToBox } from '../../model/map/IFitToBox';
import EventDispatcher from '../event/EventDispatcher';
import { Preprocessing } from '../processing/Preprocessing';
import { IFocusTo } from '../../model/map/IFocusTo';
import { CAMERA_TYPE } from '../../model/IMapOption';
import { IGetFitZoomLevel } from '../../model/map/IGetFitZoomLevel';
export declare class CameraController {
    camera: THREE.OrthographicCamera | THREE.PerspectiveCamera;
    camera3d: THREE.PerspectiveCamera;
    camera2d: THREE.OrthographicCamera;
    rtCamera: THREE.OrthographicCamera;
    controls: CameraControls;
    controls3d: CameraControls;
    controls2d: CameraControls;
    orbitControls3d: OrbitControls;
    orbitControls2d: OrbitControls;
    cameraType: CAMERA_TYPE;
    frustumSize: number;
    canvasSize: IDimension;
    beforeClientSize: IVector2;
    private eventDispatcher;
    private preprocessing;
    private mapInfo?;
    private controlOptions;
    private readonly controlDefaultOptions;
    private center;
    private store;
    private clock;
    private boundingBox;
    private initDollyDistance;
    private initZoom;
    private readonly zoomScale;
    private beforeZoom;
    private beforeTilt;
    private beforeRotation;
    private isInitialized;
    private updateEventListener;
    private wakeEventListener;
    private restEventListener;
    private sleepEventListener;
    private controlEventListener;
    private controlstartEventListener;
    private controlendEventListener;
    private lastZoomTime;
    private zoomDirty;
    private camera2dHelper;
    private camera3dHelper;
    private debugMode;
    constructor(store: Store, eventDispatcher: EventDispatcher, preprocessing: Preprocessing);
    init(store: Store, eventDispatcher: EventDispatcher, preprocessing: Preprocessing): void;
    getCamera2dHelper(): THREE.CameraHelper | null;
    getCamera3dHelper(): THREE.CameraHelper | null;
    getCamera(): THREE.OrthographicCamera | THREE.PerspectiveCamera;
    get2DCamera(): THREE.OrthographicCamera;
    get3DCamera(): THREE.PerspectiveCamera;
    getRtCamera(): THREE.OrthographicCamera;
    getFrustumSize(): number;
    getAspect(): number;
    getControls(): CameraControls;
    getInitZoom(): number;
    getCameraType(): CAMERA_TYPE;
    getNowZoom(): number;
    zoomControl(options: {
        zoom: number;
        transition?: boolean;
    }): number;
    rotateTo(rotation: number, tilt: number, transition: boolean): void;
    moveTo(x: number, y: number, z: number, transition: boolean): void;
    callThreeWorldMoveCamera(options: {
        position: IVector3;
        transition?: boolean;
    }): void;
    getCurrentZoomRatio(): number;
    camera3dDistanceTo(vec: THREE.Vector3): number;
    cameraSet(options: IControl): IControl;
    cameraReset(options?: {
        transition?: boolean;
    }): void;
    zoomIn(options?: {
        transition?: boolean;
    }): number;
    mouseWheelTest(): void;
    zoomOut(options?: {
        transition?: boolean;
    }): number;
    focusTo(options: IFitToBox): void;
    setOption(options: IControlOption): {
        controls2d: {
            maxZoom: number;
            minZoom: number;
            maxRotate: number;
            minRotate: number;
        };
        controls3d: {
            maxZoom: number;
            minZoom: number;
            maxTilt: number;
            minTilt: number;
            maxRotate: number;
            minRotate: number;
        };
    };
    getControlOptions(): IControlOption;
    setCameraSize(size: IDimension): void;
    Update(): void;
    cameraMoveTo(options: {
        position: IVector2;
        transition?: boolean;
        floorId?: string;
    }): IVector2 | undefined;
    cameraFocusTo(options: IFocusTo): IFocusTo | undefined;
    private cleanUpGroup;
    private applyMatrixTempGroup;
    getCurrentCameraInfo(): {
        zoom: number;
        tilt: number;
        rotation: number;
        center: {
            x: number;
            y: number;
            z: number;
        };
    };
    private getPoisFromId;
    private getObjectsFromId;
    private checkCameraZoomEnd;
    private shouldDispatchCameraZoomEnd;
    private getResolutionToZoomLevel;
    private getZoomLevelToResolution;
    private getZoomLevelToDistance;
    getZoomLevelToZoom(level: number): number;
    private getMeterToCentimeter;
    getCurrentCmFromPixel(pixel: number): number;
    getCurrentZoomLevel(): number;
    private zoomLevelControl;
    setControlBoundingBox(object: THREE.Object3D): void;
    setControlBoundary(): void;
    getFrustum(): THREE.Frustum;
    getZoomLevelByResolution(): number;
    getFitZoomLevel(options: Required<IGetFitZoomLevel>): number;
    private syncCamera;
    changeCamera(camerType: CAMERA_TYPE, isInit?: boolean): Promise<void>;
    private getControlAction;
    private setControlOptions;
    private setControlEvents;
    private setControls;
    private controlstart;
    private controlend;
    private control;
    private wake;
    private rest;
    private sleep;
    getCurrentRotate(): number;
    private update;
    setDefaultCameraControlOptions(): Promise<void>;
    private setZoom;
    private setPan;
    private setRotate;
    private controlRotate3d;
    private threeWorldMoveCamera;
    updateRTCameraZoom(size: THREE.Vector3): void;
}