import { GeospatialCameraInputsManager } from "./geospatialCameraInputsManager.js";
import { Vector3, Matrix } from "../Maths/math.vector.js";
import { Camera } from "./camera.js";
import type { Scene } from "../scene.js";
import type { MeshPredicate } from "../Culling/ray.core.js";
import { GeospatialLimits } from "./Limits/geospatialLimits.js";
import { GeospatialCameraMovement } from "./geospatialCameraMovement.js";
import type { IVector3Like } from "../Maths/math.like.js";
import type { EasingFunction } from "../Animations/easing.js";
type CameraOptions = {
    planetRadius: number;
};
/**
 * @experimental
 * This camera's movements are limited to a camera orbiting a globe, and as the API evolves it will introduce conversions between cartesian coordinates and true lat/long/alt
 *
 * Please note this is marked as experimental and the API (including the constructor!) will change until we remove that flag
 */
export declare class GeospatialCamera extends Camera {
    inputs: GeospatialCameraInputsManager;
    /** If supplied, will be used when picking the globe */
    pickPredicate?: MeshPredicate;
    /** Movement controller that turns input pixelDeltas into currentFrameDeltas used by camera*/
    readonly movement: GeospatialCameraMovement;
    private _tempPosition;
    private _tempCenter;
    private _viewMatrix;
    private _isViewMatrixDirty;
    private _lookAtVector;
    /** Behavior used for smooth flying animations */
    private _flyingBehavior;
    private _flyToTargets;
    constructor(name: string, scene: Scene, options: CameraOptions, pickPredicate?: MeshPredicate);
    private _center;
    /** The point on the globe that we are anchoring around. If no alternate rotation point is supplied, this will represent the center of screen*/
    get center(): Vector3;
    /**
     * Sets the camera position to orbit around a new center point
     * @param center The world position (ECEF) to orbit around
     */
    set center(center: IVector3Like);
    private _yaw;
    /**
     * Gets the camera's yaw (rotation around the geocentric normal) in radians
     */
    get yaw(): number;
    /**
     * Sets the camera's yaw (rotation around the geocentric normal). Will wrap value to [-π, π)
     * @param yaw The desired yaw angle in radians (0 = north, π/2 = east)
     */
    set yaw(yaw: number);
    private _pitch;
    /**
     * Gets the camera's pitch (angle from looking straight at globe)
     * Pitch is measured from looking straight down at planet center:
     * - zero pitch = looking straight at planet center (down)
     * - positive pitch = tilting up away from planet
     * - π/2 pitch = looking at horizon (perpendicular to geocentric normal)
     */
    get pitch(): number;
    /**
     * Sets the camera's pitch (angle from looking straight at globe). Will wrap value to [-π, π)
     * @param pitch The desired pitch angle in radians (0 = looking at planet center, π/2 = looking at horizon)
     */
    set pitch(pitch: number);
    private _radius;
    get radius(): number;
    /**
     * Sets the camera's distance from the current center point
     * @param radius The desired radius
     */
    set radius(radius: number);
    protected _checkLimits(): void;
    private _tempVect;
    private _tempEast;
    private _tempNorth;
    private _tempUp;
    private _setOrientation;
    /** The point around which the camera will geocentrically rotate. Uses center (pt we are anchored to) if no alternateRotationPt is defined */
    private get _geocentricRotationPt();
    /**
     * If camera is actively in flight, will update the target properties and use up the remaining duration from original flyTo call
     *
     * To start a new flyTo curve entirely, call into flyToAsync again (it will stop the inflight animation)
     * @param targetYaw
     * @param targetPitch
     * @param targetRadius
     * @param targetCenter
     */
    updateFlyToDestination(targetYaw?: number, targetPitch?: number, targetRadius?: number, targetCenter?: Vector3): void;
    /**
     * Animate camera towards passed in property values. If undefined, will use current value
     * @param targetYaw
     * @param targetPitch
     * @param targetRadius
     * @param targetCenter
     * @param flightDurationMs
     * @param easingFunction
     * @param centerHopScale If supplied, will define the parabolic hop height scale for center animation to create a "bounce" effect
     * @returns Promise that will return when the animation is complete (or interuppted by pointer input)
     */
    flyToAsync(targetYaw?: number, targetPitch?: number, targetRadius?: number, targetCenter?: Vector3, flightDurationMs?: number, easingFunction?: EasingFunction, centerHopScale?: number): Promise<void>;
    /**
     * Helper function to move camera towards a given point by radiusScale% of radius (by default 50%)
     * @param destination point to move towards
     * @param radiusScale value between 0 and 1, % of radius to move
     * @param durationMs duration of flight, default 1s
     * @param easingFn optional easing function for flight interpolation of properties
     * @param overshootRadiusScale optional scale to apply to the current radius to achieve a 'hop' animation
     */
    flyToPointAsync(destination: Vector3, radiusScale?: number, durationMs?: number, easingFn?: EasingFunction, overshootRadiusScale?: number): Promise<void>;
    private _limits;
    get limits(): GeospatialLimits;
    private _resetToDefault;
    /** @internal */
    _getViewMatrix(): Matrix;
    /** @internal */
    _isSynchronizedViewMatrix(): boolean;
    private _applyGeocentricTranslation;
    /**
     * This rotation keeps the camera oriented towards the globe as it orbits around it. This is different from cameraCentricRotation which is when the camera rotates around its own axis
     */
    private _applyGeocentricRotation;
    private _getCenterAndRadiusFromZoomToPoint;
    /**
     * Apply zoom by moving the camera toward/away from a target point.
     */
    private _applyZoom;
    private _zoomToPoint;
    private _zoomAlongLookAt;
    _checkInputs(): void;
    private _recalculateCenter;
    attachControl(noPreventDefault?: boolean): void;
    detachControl(): void;
}
export {};