import LngLat from './lng_lat';
import LngLatBounds from './lng_lat_bounds';
import MercatorCoordinate from './mercator_coordinate';
import Point from '../util/point';
import { mat4, mat2 } from 'gl-matrix';
import EdgeInsets from './edge_insets';
import { UnwrappedTileID, OverscaledTileID, CanonicalTileID } from '../source/tile_id';
import type { PaddingOptions } from './edge_insets';
/**
 * A single transform, generally used for a single tile to be
 * scaled, rotated, and zoomed.
 * @private
 */
declare class Transform {
    tileSize: number;
    tileZoom: number;
    lngRange: [number, number] | undefined | null;
    latRange: [number, number] | undefined | null;
    maxValidLatitude: number;
    scale: number;
    width: number;
    height: number;
    angle: number;
    rotationMatrix: mat2;
    zoomFraction: number;
    pixelsToGLUnits: [number, number];
    cameraToCenterDistance: number;
    mercatorMatrix: mat4;
    projMatrix: mat4;
    invProjMatrix: mat4;
    alignedProjMatrix: mat4;
    pixelMatrix: mat4;
    pixelMatrixInverse: mat4;
    glCoordMatrix: mat4;
    labelPlaneMatrix: mat4;
    _fov: number;
    _pitch: number;
    _zoom: number;
    _unmodified: boolean;
    _renderWorldCopies: boolean;
    _minZoom: number;
    _maxZoom: number;
    _minPitch: number;
    _maxPitch: number;
    _center: LngLat;
    _edgeInsets: EdgeInsets;
    _constraining: boolean;
    _posMatrixCache: {
        [_: string]: mat4;
    };
    _alignedPosMatrixCache: {
        [_: string]: mat4;
    };
    constructor(minZoom: number | undefined | null, maxZoom: number | undefined | null, minPitch: number | undefined | null, maxPitch: number | undefined | null, renderWorldCopies: boolean);
    clone(): Transform;
    get minZoom(): number;
    set minZoom(zoom: number);
    get maxZoom(): number;
    set maxZoom(zoom: number);
    get minPitch(): number;
    set minPitch(pitch: number);
    get maxPitch(): number;
    set maxPitch(pitch: number);
    get renderWorldCopies(): boolean;
    set renderWorldCopies(renderWorldCopies: boolean | undefined | null);
    get worldSize(): number;
    get centerOffset(): Point;
    get size(): Point;
    get bearing(): number;
    set bearing(bearing: number);
    get pitch(): number;
    set pitch(pitch: number);
    get fov(): number;
    set fov(fov: number);
    get zoom(): number;
    set zoom(zoom: number);
    get center(): LngLat;
    set center(center: LngLat);
    get padding(): PaddingOptions;
    set padding(padding: PaddingOptions);
    /**
     * The center of the screen in pixels with the top-left corner being (0,0)
     * and +y axis pointing downwards. This accounts for padding.
     *
     * @readonly
     * @type {Point}
     * @memberof Transform
     */
    get centerPoint(): Point;
    /**
     * Returns if the padding params match
     *
     * @param {PaddingOptions} padding the padding to check against
     * @returns {boolean} true if they are equal, false otherwise
     * @memberof Transform
     */
    isPaddingEqual(padding: PaddingOptions): boolean;
    /**
     * Helper method to upadte edge-insets inplace
     *
     * @param {PaddingOptions} start the starting padding
     * @param {PaddingOptions} target the target padding
     * @param {number} t the step/weight
     * @memberof Transform
     */
    interpolatePadding(start: PaddingOptions, target: PaddingOptions, t: number): void;
    /**
     * Return a zoom level that will cover all tiles the transform
     * @param {Object} options options
     * @param {number} options.tileSize Tile size, expressed in screen pixels.
     * @param {boolean} options.roundZoom Target zoom level. If true, the value will be rounded to the closest integer. Otherwise the value will be floored.
     * @returns {number} zoom level An integer zoom level at which all tiles will be visible.
     */
    coveringZoomLevel(options: {
        roundZoom?: boolean;
        tileSize: number;
    }): number;
    /**
     * Return any "wrapped" copies of a given tile coordinate that are visible
     * in the current view.
     *
     * @private
     */
    getVisibleUnwrappedCoordinates(tileID: CanonicalTileID): UnwrappedTileID[];
    /**
     * Return all coordinates that could cover this transform for a covering
     * zoom level.
     * @param {Object} options
     * @param {number} options.tileSize
     * @param {number} options.minzoom
     * @param {number} options.maxzoom
     * @param {boolean} options.roundZoom
     * @param {boolean} options.reparseOverscaled
     * @param {boolean} options.renderWorldCopies
     * @returns {Array<OverscaledTileID>} OverscaledTileIDs
     * @private
     */
    coveringTiles(options: {
        tileSize: number;
        minzoom?: number;
        maxzoom?: number;
        roundZoom?: boolean;
        reparseOverscaled?: boolean;
        renderWorldCopies?: boolean;
    }): Array<OverscaledTileID>;
    resize(width: number, height: number): void;
    get unmodified(): boolean;
    zoomScale(zoom: number): number;
    scaleZoom(scale: number): number;
    project(lnglat: LngLat): Point;
    unproject(point: Point): LngLat;
    get point(): Point;
    setLocationAtPoint(lnglat: LngLat, point: Point): void;
    /**
     * Given a location, return the screen point that corresponds to it
     * @param {LngLat} lnglat location
     * @returns {Point} screen point
     * @private
     */
    locationPoint(lnglat: LngLat): Point;
    /**
     * Given a point on screen, return its lnglat
     * @param {Point} p screen point
     * @returns {LngLat} lnglat location
     * @private
     */
    pointLocation(p: Point): LngLat;
    /**
     * Given a geographical lnglat, return an unrounded
     * coordinate that represents it at this transform's zoom level.
     * @param {LngLat} lnglat
     * @returns {Coordinate}
     * @private
     */
    locationCoordinate(lnglat: LngLat): MercatorCoordinate;
    /**
     * Given a Coordinate, return its geographical position.
     * @param {Coordinate} coord
     * @returns {LngLat} lnglat
     * @private
     */
    coordinateLocation(coord: MercatorCoordinate): LngLat;
    pointCoordinate(p: Point): MercatorCoordinate;
    /**
     * Given a coordinate, return the screen point that corresponds to it
     * @param {Coordinate} coord
     * @returns {Point} screen point
     * @private
     */
    coordinatePoint(coord: MercatorCoordinate): Point;
    /**
     * Returns the map's geographical bounds. When the bearing or pitch is non-zero, the visible region is not
     * an axis-aligned rectangle, and the result is the smallest bounds that encompasses the visible region.
     * @returns {LngLatBounds} Returns a {@link LngLatBounds} object describing the map's geographical bounds.
     */
    getBounds(): LngLatBounds;
    /**
     * Returns the maximum geographical bounds the map is constrained to, or `null` if none set.
     * @returns {LngLatBounds} {@link LngLatBounds}
     */
    getMaxBounds(): LngLatBounds | null;
    /**
     * Sets or clears the map's geographical constraints.
     * @param {LngLatBounds} bounds A {@link LngLatBounds} object describing the new geographic boundaries of the map.
     */
    setMaxBounds(bounds?: LngLatBounds): void;
    /**
     * Calculate the posMatrix that, given a tile coordinate, would be used to display the tile on a map.
     * @param {UnwrappedTileID} unwrappedTileID;
     * @private
     */
    calculatePosMatrix(unwrappedTileID: UnwrappedTileID, aligned?: boolean): mat4;
    customLayerMatrix(): mat4;
    _constrain(): void;
    _calcMatrices(): void;
    maxPitchScaleFactor(): number;
    getCameraPoint(): Point;
    getCameraQueryGeometry(queryGeometry: Array<Point>): Array<Point>;
}
export default Transform;
//# sourceMappingURL=transform.d.ts.map