import Vector2 from '../math/Vector2';
import { PinchEvent } from './GestureMgr';
import Notifier from '../core/Notifier';
import Timeline from '../Timeline';
import type { vec3 } from '../glmatrix';
import type { AnimationEasing } from '../animation/easing';
import type ProceduralKeyframeAnimator from '../animation/ProceduralKeyframeAnimator';
import Camera from '../Camera';
type AnimatableControlOpts = Pick<OrbitControlOpts, 'distance' | 'orthographicSize' | 'alpha' | 'beta' | 'center'>;
type MouseButtons = 'left' | 'right' | 'middle';
type ShiftKey = 'shift';
type MouseButtonsWithSpecialKey = `${ShiftKey}+${MouseButtons}` | MouseButtons;
interface OrbitControlOpts {
    target: Camera;
    timeline?: Timeline;
    domElement: HTMLElement;
    /**
     * States of orbit
     */
    distance: number;
    orthographicSize: number;
    alpha: number;
    beta: number;
    center: vec3.Vec3Array;
    /**
     * Minimum distance to the center
     * @type {number}
     * @default 0.5
     */
    minDistance: number;
    /**
     * Maximum distance to the center
     * @type {number}
     * @default 2
     */
    maxDistance: number;
    /**
     * Only available when camera is orthographic
     */
    maxOrthographicSize: number;
    /**
     * Only available when camera is orthographic
     */
    minOrthographicSize: number;
    /**
     * Aspect of orthographic camera
     * Only available when camera is orthographic
     */
    aspect: number;
    /**
     * Minimum alpha rotation
     */
    minAlpha: number;
    /**
     * Maximum alpha rotation
     */
    maxAlpha: number;
    /**
     * Minimum beta rotation
     */
    minBeta: number;
    /**
     * Maximum beta rotation
     */
    maxBeta: number;
    /**
     * Start auto rotating after still for the given time
     */
    autoRotateAfterStill: number;
    /**
     * Direction of autoRotate. cw or ccw when looking top down.
     */
    autoRotateDirection: 'cw' | 'ccw';
    /**
     * Degree per second
     */
    autoRotateSpeed: number;
    panMouseButton: MouseButtonsWithSpecialKey;
    rotateMouseButton: MouseButtonsWithSpecialKey;
    damping: number;
    rotateSensitivity: number;
    zoomSensitivity: number;
    /**
     * Invert zoom direction?
     */
    invertZoomDirection: false;
    panSensitivity: number;
    autoRotate: boolean;
}
interface OrbitControl extends Omit<OrbitControlOpts, 'autoRotate' | 'target' | 'distance' | 'orthographicSize' | 'alpha' | 'beta' | 'center'> {
}
declare class OrbitControl extends Notifier {
    disabled: boolean;
    private _autoRotate;
    private _target?;
    private _center;
    private _orthoSize?;
    private _mode?;
    private _needsUpdate;
    private _rotating;
    private _phi;
    private _theta;
    private _mouseX;
    private _mouseY;
    private _rotateVelocity;
    private _panVelocity;
    private _distance;
    private _zoomSpeed;
    private _stillTimeout;
    private _animators;
    private _gestureMgr;
    constructor(opts: Omit<Partial<OrbitControlOpts>, 'domElement'> & {
        domElement: HTMLElement;
    });
    /**
     * If auto rotate the target
     */
    get autoRotate(): boolean;
    set autoRotate(val: boolean);
    get target(): Camera | undefined;
    set target(val: Camera | undefined);
    /**
     * Initialize.
     * Mouse event binding
     */
    init(): void;
    /**
     * Dispose.
     * Mouse event unbinding
     */
    dispose(): void;
    /**
     * Get distance
     * @return {number}
     */
    getDistance(): number;
    /**
     * Set distance
     * @param {number} distance
     */
    setDistance(distance: number): void;
    /**
     * Get size of orthographic viewing volume
     * @return {number}
     */
    getOrthographicSize(): number | undefined;
    /**
     * Set size of orthographic viewing volume
     * @param {number} size
     */
    setOrthographicSize(size: number): void;
    /**
     * Get alpha rotation
     * Alpha angle for top-down rotation. Positive to rotate to top.
     *
     * Which means camera rotation around x axis.
     */
    getAlpha(): number;
    /**
     * Get beta rotation
     * Beta angle for left-right rotation. Positive to rotate to right.
     *
     * Which means camera rotation around y axis.
     */
    getBeta(): number;
    /**
     * Get control center
     * @return {Array.<number>}
     */
    getCenter(): vec3.Vec3Array;
    /**
     * Set alpha rotation angle
     * @param {number} alpha
     */
    setAlpha(alpha: number): void;
    /**
     * Set beta rotation angle
     * @param {number} beta
     */
    setBeta(beta: number): void;
    /**
     * Set control center
     * @param {Array.<number>} center
     */
    setCenter(centerArr: vec3.Vec3Array): void;
    setOption(opts?: Partial<OrbitControlOpts>): void;
    animateTo(opts: Partial<AnimatableControlOpts & {
        duration: number;
        easing: AnimationEasing;
        done: () => void;
    }>): ProceduralKeyframeAnimator<any> | undefined;
    /**
     * Stop all animations
     */
    stopAllAnimation(): void;
    _isAnimating(): boolean;
    /**
     * Call update each frame
     * @param  {number} deltaTime Frame time
     */
    update(deltaTime?: number): void;
    _updateRotate(deltaTime: number): void;
    _updateDistanceOrSize(deltaTime: number): void;
    _setDistance(distance: number): void;
    _setOrthoSize(size: number): void;
    _updatePan(deltaTime: number): void;
    _updateTransform(): void;
    _startCountingStill(): void;
    _vectorDamping(v: Vector2, damping: number): void;
    decomposeTransform(): void;
    _pointerDownHandler(e: MouseEvent | TouchEvent): void;
    _pointerMoveHandler(e: MouseEvent | TouchEvent): void;
    _mouseWheelHandler(e: WheelEvent): void;
    _pinchHandler(e: PinchEvent): void;
    _zoomHandler(e: WheelEvent, delta: number): void;
    _pointerUpHandler(event: MouseEvent | TouchEvent): void;
    _releaseGlobalEvent(): void;
    _addAnimator(animator: ProceduralKeyframeAnimator): ProceduralKeyframeAnimator<any>;
    _processGesture(event: TouchEvent, stage: 'start' | 'end' | 'change'): {
        type: "pinch";
        target: any;
        event: PinchEvent;
    } | undefined;
}
export default OrbitControl;