@types/mapbox-gl

  • Version 2.7.8
  • Published
  • 98 kB
  • 1 dependency
  • MIT license

Install

npm i @types/mapbox-gl
yarn add @types/mapbox-gl
pnpm add @types/mapbox-gl

Overview

TypeScript definitions for Mapbox GL JS

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable accessToken

let accessToken: string;

    variable baseApiUrl

    let baseApiUrl: string;

      variable maxParallelImageRequests

      let maxParallelImageRequests: number;
      • Maximum number of images (raster tiles, sprites, icons) to load in parallel, which affects performance in raster-heavy maps. 16 by default.

      variable version

      let version: string;

        variable workerCount

        let workerCount: number;
        • Number of web workers instantiated on a page with GL JS maps. By default, it is set to half the number of CPU cores (capped at 6).

        Functions

        function clearPrewarmedResources

        clearPrewarmedResources: () => void;
        • Clears up resources that have previously been created by mapboxgl.prewarm(). Note that this is typically not necessary. You should only call this function if you expect the user of your app to not return to a Map view at any point in your application.

        function clearStorage

        clearStorage: (callback?: (err?: Error) => void) => void;
        • Clears browser storage used by this library. Using this method flushes the Mapbox tile cache that is managed by this library. Tiles may still be cached by the browser in some cases.

        function getRTLTextPluginStatus

        getRTLTextPluginStatus: () => PluginStatus;

          function prewarm

          prewarm: () => void;
          • Initializes resources like WebWorkers that can be shared across maps to lower load times in some situations. mapboxgl.workerUrl and mapboxgl.workerCount, if being used, must be set before prewarm() is called to have an effect.

            By default, the lifecycle of these resources is managed automatically, and they are lazily initialized when a Map is first created. By invoking prewarm(), these resources will be created ahead of time, and will not be cleared when the last Map is removed from the page. This allows them to be re-used by new Map instances that are created later. They can be manually cleared by calling mapboxgl.clearPrewarmedResources(). This is only necessary if your web page remains active but stops using maps altogether.

            This is primarily useful when using GL-JS maps in a single page app, wherein a user would navigate between various views that can cause Map instances to constantly be created and destroyed.

          function setRTLTextPlugin

          setRTLTextPlugin: (
          pluginURL: string,
          callback: (error: Error) => void,
          deferred?: boolean
          ) => void;

            function supported

            supported: (options?: {
            failIfMajorPerformanceCaveat?: boolean | undefined;
            }) => boolean;

              Classes

              class AttributionControl

              class AttributionControl extends Control {}
              • Attribution

              constructor

              constructor(options?: {
              compact?: boolean | undefined;
              customAttribution?: string | string[] | undefined;
              });

                class BoxZoomHandler

                class BoxZoomHandler {}
                • BoxZoomHandler

                constructor

                constructor(map: Map);

                  method disable

                  disable: () => void;

                    method enable

                    enable: () => void;

                      method isActive

                      isActive: () => boolean;

                        method isEnabled

                        isEnabled: () => boolean;

                          class CanvasSource

                          class CanvasSource implements CanvasSourceRaw {}

                            property canvas

                            canvas: string | HTMLCanvasElement;

                              property coordinates

                              coordinates: number[][];

                                property type

                                type: string;

                                  method getCanvas

                                  getCanvas: () => HTMLCanvasElement;

                                    method pause

                                    pause: () => void;

                                      method play

                                      play: () => void;

                                        method setCoordinates

                                        setCoordinates: (coordinates: number[][]) => this;

                                          class Control

                                          class Control extends Evented implements IControl {}
                                          • Control

                                          property getDefaultPosition

                                          getDefaultPosition?: () => string;

                                            method onAdd

                                            onAdd: (map: Map) => HTMLElement;

                                              method onRemove

                                              onRemove: (map: Map) => void;

                                                class DoubleClickZoomHandler

                                                class DoubleClickZoomHandler {}
                                                • DoubleClickZoomHandler

                                                constructor

                                                constructor(map: Map);

                                                  method disable

                                                  disable: () => void;

                                                    method enable

                                                    enable: () => void;

                                                      method isEnabled

                                                      isEnabled: () => boolean;

                                                        class DragPanHandler

                                                        class DragPanHandler {}
                                                        • DragPenHandler

                                                        constructor

                                                        constructor(map: Map);

                                                          method disable

                                                          disable: () => void;

                                                            method enable

                                                            enable: (options?: DragPanOptions) => void;

                                                              method isActive

                                                              isActive: () => boolean;

                                                                method isEnabled

                                                                isEnabled: () => boolean;

                                                                  class DragRotateHandler

                                                                  class DragRotateHandler {}
                                                                  • DragRotateHandler

                                                                  constructor

                                                                  constructor(
                                                                  map: Map,
                                                                  options?: {
                                                                  bearingSnap?: number | undefined;
                                                                  pitchWithRotate?: boolean | undefined;
                                                                  }
                                                                  );

                                                                    method disable

                                                                    disable: () => void;

                                                                      method enable

                                                                      enable: () => void;

                                                                        method isActive

                                                                        isActive: () => boolean;

                                                                          method isEnabled

                                                                          isEnabled: () => boolean;

                                                                            class ErrorEvent

                                                                            class ErrorEvent extends MapboxEvent {}

                                                                              property error

                                                                              error: Error;

                                                                                property type

                                                                                type: string;

                                                                                  class Evented

                                                                                  class Evented {}
                                                                                  • Evented

                                                                                  method fire

                                                                                  fire: (type: string, properties?: { [key: string]: any }) => this;

                                                                                    method off

                                                                                    off: (type?: string | any, listener?: EventedListener) => this;

                                                                                      method on

                                                                                      on: (type: string, listener: EventedListener) => this;

                                                                                        method once

                                                                                        once: (type: string, listener: EventedListener) => this;

                                                                                          class FreeCameraOptions

                                                                                          class FreeCameraOptions {}
                                                                                          • Various options for accessing physical properties of the underlying camera entity. A direct access to these properties allows more flexible and precise controlling of the camera while also being fully compatible and interchangeable with CameraOptions. All fields are optional. See Camera#setFreeCameraOptions and Camera#getFreeCameraOptions

                                                                                            Parameter position

                                                                                            Position of the camera in slightly modified web mercator coordinates - The size of 1 unit is the width of the projected world instead of the "mercator meter". Coordinate [0, 0, 0] is the north-west corner and [1, 1, 0] is the south-east corner. - Z coordinate is conformal and must respect minimum and maximum zoom values. - Zoom is automatically computed from the altitude (z)

                                                                                            Parameter orientation

                                                                                            Orientation of the camera represented as a unit quaternion [x, y, z, w] in a left-handed coordinate space. Direction of the rotation is clockwise around the respective axis. The default pose of the camera is such that the forward vector is looking up the -Z axis and the up vector is aligned with north orientation of the map: forward: [0, 0, -1] up: [0, -1, 0] right [1, 0, 0] Orientation can be set freely but certain constraints still apply - Orientation must be representable with only pitch and bearing. - Pitch has an upper limit

                                                                                          constructor

                                                                                          constructor(position?: MercatorCoordinate, orientation?: quat);

                                                                                            property position

                                                                                            position: MercatorCoordinate;

                                                                                              method lookAtPoint

                                                                                              lookAtPoint: (location: LngLatLike, up?: vec3) => void;
                                                                                              • Helper function for setting orientation of the camera by defining a focus point on the map.

                                                                                                Parameter location

                                                                                                Location of the focus point on the map

                                                                                                Parameter up

                                                                                                Up vector of the camera is required in certain scenarios where bearing can't be deduced from the viewing direction.

                                                                                              method setPitchBearing

                                                                                              setPitchBearing: (pitch: number, bearing: number) => void;
                                                                                              • Helper function for setting the orientation of the camera as a pitch and a bearing.

                                                                                                Parameter pitch

                                                                                                Pitch angle in degrees

                                                                                                Parameter bearing

                                                                                                Bearing angle in degrees

                                                                                              class FullscreenControl

                                                                                              class FullscreenControl extends Control {}
                                                                                              • FullscreenControl

                                                                                              constructor

                                                                                              constructor(options?: FullscreenControlOptions);

                                                                                                class GeoJSONSource

                                                                                                class GeoJSONSource implements GeoJSONSourceRaw {}

                                                                                                  constructor

                                                                                                  constructor(options?: GeoJSONSourceOptions);

                                                                                                    property type

                                                                                                    type: string;

                                                                                                      method getClusterChildren

                                                                                                      getClusterChildren: (
                                                                                                      clusterId: number,
                                                                                                      callback: (error: any, features: GeoJSON.Feature<GeoJSON.Geometry>[]) => void
                                                                                                      ) => this;

                                                                                                        method getClusterExpansionZoom

                                                                                                        getClusterExpansionZoom: (
                                                                                                        clusterId: number,
                                                                                                        callback: (error: any, zoom: number) => void
                                                                                                        ) => this;

                                                                                                          method getClusterLeaves

                                                                                                          getClusterLeaves: (
                                                                                                          cluserId: number,
                                                                                                          limit: number,
                                                                                                          offset: number,
                                                                                                          callback: (error: any, features: GeoJSON.Feature<GeoJSON.Geometry>[]) => void
                                                                                                          ) => this;

                                                                                                            method setData

                                                                                                            setData: (
                                                                                                            data:
                                                                                                            | GeoJSON.Feature<GeoJSON.Geometry>
                                                                                                            | GeoJSON.FeatureCollection<GeoJSON.Geometry>
                                                                                                            | String
                                                                                                            ) => this;

                                                                                                              class GeolocateControl

                                                                                                              class GeolocateControl extends Control {}
                                                                                                              • Geolocate

                                                                                                              constructor

                                                                                                              constructor(options?: {
                                                                                                              positionOptions?: PositionOptions;
                                                                                                              fitBoundsOptions?: FitBoundsOptions | undefined;
                                                                                                              trackUserLocation?: boolean | undefined;
                                                                                                              showAccuracyCircle?: boolean | undefined;
                                                                                                              showUserLocation?: boolean | undefined;
                                                                                                              showUserHeading?: boolean | undefined;
                                                                                                              geolocation?: Geolocation | undefined;
                                                                                                              });

                                                                                                                method trigger

                                                                                                                trigger: () => boolean;

                                                                                                                  class ImageSource

                                                                                                                  class ImageSource implements ImageSourceRaw {}

                                                                                                                    constructor

                                                                                                                    constructor(options?: ImageSourceOptions);

                                                                                                                      property type

                                                                                                                      type: string;

                                                                                                                        method setCoordinates

                                                                                                                        setCoordinates: (coordinates: number[][]) => this;

                                                                                                                          method updateImage

                                                                                                                          updateImage: (options: ImageSourceOptions) => this;

                                                                                                                            class KeyboardHandler

                                                                                                                            class KeyboardHandler {}
                                                                                                                            • KeyboardHandler

                                                                                                                            constructor

                                                                                                                            constructor(map: Map);

                                                                                                                              method disable

                                                                                                                              disable: () => void;

                                                                                                                                method disableRotation

                                                                                                                                disableRotation: () => void;
                                                                                                                                • Disables the "keyboard pan/rotate" interaction, leaving the "keyboard zoom" interaction enabled.

                                                                                                                                  Example 1

                                                                                                                                  map.keyboard.disableRotation();

                                                                                                                                method enable

                                                                                                                                enable: () => void;

                                                                                                                                  method enableRotation

                                                                                                                                  enableRotation: () => void;
                                                                                                                                  • Enables the "keyboard pan/rotate" interaction.

                                                                                                                                    Example 1

                                                                                                                                    map.keyboard.enable(); map.keyboard.enableRotation();

                                                                                                                                  method isActive

                                                                                                                                  isActive: () => boolean;
                                                                                                                                  • Returns true if the handler is enabled and has detected the start of a zoom/rotate gesture.

                                                                                                                                    Returns

                                                                                                                                    {boolean} true if the handler is enabled and has detected the start of a zoom/rotate gesture.

                                                                                                                                  method isEnabled

                                                                                                                                  isEnabled: () => boolean;

                                                                                                                                    class LngLat

                                                                                                                                    class LngLat {}
                                                                                                                                    • LngLat

                                                                                                                                    constructor

                                                                                                                                    constructor(lng: number, lat: number);

                                                                                                                                      property lat

                                                                                                                                      lat: number;

                                                                                                                                        property lng

                                                                                                                                        lng: number;

                                                                                                                                          method convert

                                                                                                                                          static convert: (input: LngLatLike) => LngLat;

                                                                                                                                            method distanceTo

                                                                                                                                            distanceTo: (lngLat: LngLat) => number;
                                                                                                                                            • Returns the approximate distance between a pair of coordinates in meters Uses the Haversine Formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159)

                                                                                                                                            method toArray

                                                                                                                                            toArray: () => number[];
                                                                                                                                            • Return a LngLat as an array

                                                                                                                                            method toBounds

                                                                                                                                            toBounds: (radius: number) => LngLatBounds;

                                                                                                                                              method toString

                                                                                                                                              toString: () => string;
                                                                                                                                              • Return a LngLat as a string

                                                                                                                                              method wrap

                                                                                                                                              wrap: () => LngLat;
                                                                                                                                              • Return a new LngLat object whose longitude is wrapped to the range (-180, 180).

                                                                                                                                              class LngLatBounds

                                                                                                                                              class LngLatBounds {}
                                                                                                                                              • LngLatBounds

                                                                                                                                              constructor

                                                                                                                                              constructor(
                                                                                                                                              boundsLike?: [number, number, number, number] | [LngLatLike, LngLatLike]
                                                                                                                                              );

                                                                                                                                                constructor

                                                                                                                                                constructor(sw: LngLatLike, ne: LngLatLike);

                                                                                                                                                  property ne

                                                                                                                                                  ne: LngLatLike;

                                                                                                                                                    property sw

                                                                                                                                                    sw: LngLatLike;

                                                                                                                                                      method contains

                                                                                                                                                      contains: (lnglat: LngLatLike) => boolean;
                                                                                                                                                      • Check if the point is within the bounding box.

                                                                                                                                                      method convert

                                                                                                                                                      static convert: (input: LngLatBoundsLike) => LngLatBounds;
                                                                                                                                                      • Convert an array to a LngLatBounds object, or return an existing LngLatBounds object unchanged.

                                                                                                                                                      method extend

                                                                                                                                                      extend: (obj: mapboxgl.LngLatLike | mapboxgl.LngLatBoundsLike) => this;
                                                                                                                                                      • Extend the bounds to include a given LngLat or LngLatBounds.

                                                                                                                                                      method getCenter

                                                                                                                                                      getCenter: () => LngLat;
                                                                                                                                                      • Get the point equidistant from this box's corners

                                                                                                                                                      method getEast

                                                                                                                                                      getEast: () => number;
                                                                                                                                                      • Get east edge longitude

                                                                                                                                                      method getNorth

                                                                                                                                                      getNorth: () => number;
                                                                                                                                                      • Get north edge latitude

                                                                                                                                                      method getNorthEast

                                                                                                                                                      getNorthEast: () => LngLat;
                                                                                                                                                      • Get northeast corner

                                                                                                                                                      method getNorthWest

                                                                                                                                                      getNorthWest: () => LngLat;
                                                                                                                                                      • Get northwest corner

                                                                                                                                                      method getSouth

                                                                                                                                                      getSouth: () => number;
                                                                                                                                                      • Get south edge latitude

                                                                                                                                                      method getSouthEast

                                                                                                                                                      getSouthEast: () => LngLat;
                                                                                                                                                      • Get southeast corner

                                                                                                                                                      method getSouthWest

                                                                                                                                                      getSouthWest: () => LngLat;
                                                                                                                                                      • Get southwest corner

                                                                                                                                                      method getWest

                                                                                                                                                      getWest: () => number;
                                                                                                                                                      • Get west edge longitude

                                                                                                                                                      method isEmpty

                                                                                                                                                      isEmpty: () => boolean;
                                                                                                                                                      • Returns a boolean

                                                                                                                                                      method setNorthEast

                                                                                                                                                      setNorthEast: (ne: LngLatLike) => this;

                                                                                                                                                        method setSouthWest

                                                                                                                                                        setSouthWest: (sw: LngLatLike) => this;

                                                                                                                                                          method toArray

                                                                                                                                                          toArray: () => number[][];
                                                                                                                                                          • Returns a LngLatBounds as an array

                                                                                                                                                          method toString

                                                                                                                                                          toString: () => string;
                                                                                                                                                          • Return a LngLatBounds as a string

                                                                                                                                                          class Map

                                                                                                                                                          class Map extends Evented {}
                                                                                                                                                          • Map

                                                                                                                                                          constructor

                                                                                                                                                          constructor(options?: MapboxOptions);

                                                                                                                                                            property boxZoom

                                                                                                                                                            boxZoom: BoxZoomHandler;

                                                                                                                                                              property doubleClickZoom

                                                                                                                                                              doubleClickZoom: DoubleClickZoomHandler;

                                                                                                                                                                property dragPan

                                                                                                                                                                dragPan: DragPanHandler;

                                                                                                                                                                  property dragRotate

                                                                                                                                                                  dragRotate: DragRotateHandler;

                                                                                                                                                                    property keyboard

                                                                                                                                                                    keyboard: KeyboardHandler;

                                                                                                                                                                      property repaint

                                                                                                                                                                      repaint: boolean;

                                                                                                                                                                        property scrollZoom

                                                                                                                                                                        scrollZoom: ScrollZoomHandler;

                                                                                                                                                                          property showCollisionBoxes

                                                                                                                                                                          showCollisionBoxes: boolean;

                                                                                                                                                                            property showPadding

                                                                                                                                                                            showPadding: boolean;
                                                                                                                                                                            • Gets and sets a Boolean indicating whether the map will visualize the padding offsets.

                                                                                                                                                                              showPadding {boolean} Map

                                                                                                                                                                            property showTerrainWireframe

                                                                                                                                                                            showTerrainWireframe: boolean;

                                                                                                                                                                              property showTileBoundaries

                                                                                                                                                                              showTileBoundaries: boolean;

                                                                                                                                                                                property touchPitch

                                                                                                                                                                                touchPitch: TouchPitchHandler;

                                                                                                                                                                                  property touchZoomRotate

                                                                                                                                                                                  touchZoomRotate: TouchZoomRotateHandler;

                                                                                                                                                                                    method addControl

                                                                                                                                                                                    addControl: (
                                                                                                                                                                                    control: Control | IControl,
                                                                                                                                                                                    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'
                                                                                                                                                                                    ) => this;

                                                                                                                                                                                      method addImage

                                                                                                                                                                                      addImage: (
                                                                                                                                                                                      name: string,
                                                                                                                                                                                      image:
                                                                                                                                                                                      | HTMLImageElement
                                                                                                                                                                                      | ArrayBufferView
                                                                                                                                                                                      | { width: number; height: number; data: Uint8Array | Uint8ClampedArray }
                                                                                                                                                                                      | ImageData
                                                                                                                                                                                      | ImageBitmap,
                                                                                                                                                                                      options?: { pixelRatio?: number | undefined; sdf?: boolean | undefined }
                                                                                                                                                                                      ) => void;

                                                                                                                                                                                        method addLayer

                                                                                                                                                                                        addLayer: (layer: mapboxgl.AnyLayer, before?: string) => this;

                                                                                                                                                                                          method addSource

                                                                                                                                                                                          addSource: (id: string, source: AnySourceData) => this;

                                                                                                                                                                                            method areTilesLoaded

                                                                                                                                                                                            areTilesLoaded: () => boolean;

                                                                                                                                                                                              method cameraForBounds

                                                                                                                                                                                              cameraForBounds: (
                                                                                                                                                                                              bounds: LngLatBoundsLike,
                                                                                                                                                                                              options?: CameraForBoundsOptions
                                                                                                                                                                                              ) => CameraForBoundsResult | undefined;

                                                                                                                                                                                                method easeTo

                                                                                                                                                                                                easeTo: (
                                                                                                                                                                                                options: mapboxgl.EaseToOptions,
                                                                                                                                                                                                eventData?: mapboxgl.EventData
                                                                                                                                                                                                ) => this;

                                                                                                                                                                                                  method fitBounds

                                                                                                                                                                                                  fitBounds: (
                                                                                                                                                                                                  bounds: LngLatBoundsLike,
                                                                                                                                                                                                  options?: mapboxgl.FitBoundsOptions,
                                                                                                                                                                                                  eventData?: mapboxgl.EventData
                                                                                                                                                                                                  ) => this;

                                                                                                                                                                                                    method fitScreenCoordinates

                                                                                                                                                                                                    fitScreenCoordinates: (
                                                                                                                                                                                                    p0: PointLike,
                                                                                                                                                                                                    p1: PointLike,
                                                                                                                                                                                                    bearing: number,
                                                                                                                                                                                                    options?: AnimationOptions & CameraOptions,
                                                                                                                                                                                                    eventData?: EventData
                                                                                                                                                                                                    ) => this;

                                                                                                                                                                                                      method flyTo

                                                                                                                                                                                                      flyTo: (options: mapboxgl.FlyToOptions, eventData?: mapboxgl.EventData) => this;

                                                                                                                                                                                                        method getBearing

                                                                                                                                                                                                        getBearing: () => number;

                                                                                                                                                                                                          method getBounds

                                                                                                                                                                                                          getBounds: () => LngLatBounds;

                                                                                                                                                                                                            method getCanvas

                                                                                                                                                                                                            getCanvas: () => HTMLCanvasElement;

                                                                                                                                                                                                              method getCanvasContainer

                                                                                                                                                                                                              getCanvasContainer: () => HTMLElement;

                                                                                                                                                                                                                method getCenter

                                                                                                                                                                                                                getCenter: () => LngLat;

                                                                                                                                                                                                                  method getContainer

                                                                                                                                                                                                                  getContainer: () => HTMLElement;

                                                                                                                                                                                                                    method getFeatureState

                                                                                                                                                                                                                    getFeatureState: (
                                                                                                                                                                                                                    feature: FeatureIdentifier | mapboxgl.MapboxGeoJSONFeature
                                                                                                                                                                                                                    ) => { [key: string]: any };

                                                                                                                                                                                                                      method getFilter

                                                                                                                                                                                                                      getFilter: (layer: string) => any[];

                                                                                                                                                                                                                        method getFog

                                                                                                                                                                                                                        getFog: () => Fog | null;

                                                                                                                                                                                                                          method getFreeCameraOptions

                                                                                                                                                                                                                          getFreeCameraOptions: () => FreeCameraOptions;
                                                                                                                                                                                                                          • Returns position and orientation of the camera entity.

                                                                                                                                                                                                                            Map#

                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                            {FreeCameraOptions} The camera state

                                                                                                                                                                                                                          method getLayer

                                                                                                                                                                                                                          getLayer: (id: string) => mapboxgl.AnyLayer;

                                                                                                                                                                                                                            method getLayoutProperty

                                                                                                                                                                                                                            getLayoutProperty: (layer: string, name: string) => any;

                                                                                                                                                                                                                              method getLight

                                                                                                                                                                                                                              getLight: () => mapboxgl.Light;

                                                                                                                                                                                                                                method getMaxBounds

                                                                                                                                                                                                                                getMaxBounds: () => LngLatBounds;

                                                                                                                                                                                                                                  method getMaxPitch

                                                                                                                                                                                                                                  getMaxPitch: () => number;

                                                                                                                                                                                                                                    method getMaxZoom

                                                                                                                                                                                                                                    getMaxZoom: () => number;

                                                                                                                                                                                                                                      method getMinPitch

                                                                                                                                                                                                                                      getMinPitch: () => number;

                                                                                                                                                                                                                                        method getMinZoom

                                                                                                                                                                                                                                        getMinZoom: () => number;

                                                                                                                                                                                                                                          method getPadding

                                                                                                                                                                                                                                          getPadding: () => PaddingOptions;
                                                                                                                                                                                                                                          • Returns the current padding applied around the map viewport.

                                                                                                                                                                                                                                            Map#

                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                            The current padding around the map viewport.

                                                                                                                                                                                                                                          method getPaintProperty

                                                                                                                                                                                                                                          getPaintProperty: (layer: string, name: string) => any;

                                                                                                                                                                                                                                            method getPitch

                                                                                                                                                                                                                                            getPitch: () => number;

                                                                                                                                                                                                                                              method getRenderWorldCopies

                                                                                                                                                                                                                                              getRenderWorldCopies: () => boolean;

                                                                                                                                                                                                                                                method getSource

                                                                                                                                                                                                                                                getSource: (id: string) => AnySourceImpl;

                                                                                                                                                                                                                                                  method getStyle

                                                                                                                                                                                                                                                  getStyle: () => mapboxgl.Style;

                                                                                                                                                                                                                                                    method getTerrain

                                                                                                                                                                                                                                                    getTerrain: () => TerrainSpecification | null;

                                                                                                                                                                                                                                                      method getZoom

                                                                                                                                                                                                                                                      getZoom: () => number;

                                                                                                                                                                                                                                                        method hasControl

                                                                                                                                                                                                                                                        hasControl: (control: IControl) => boolean;
                                                                                                                                                                                                                                                        • Checks if a control exists on the map.

                                                                                                                                                                                                                                                          Parameter control

                                                                                                                                                                                                                                                          The IControl to check.

                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                          {boolean} True if map contains control.

                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                        method hasImage

                                                                                                                                                                                                                                                        hasImage: (name: string) => boolean;

                                                                                                                                                                                                                                                          method isEasing

                                                                                                                                                                                                                                                          isEasing: () => boolean;

                                                                                                                                                                                                                                                            method isMoving

                                                                                                                                                                                                                                                            isMoving: () => boolean;

                                                                                                                                                                                                                                                              method isRotating

                                                                                                                                                                                                                                                              isRotating: () => boolean;

                                                                                                                                                                                                                                                                method isSourceLoaded

                                                                                                                                                                                                                                                                isSourceLoaded: (id: string) => boolean;

                                                                                                                                                                                                                                                                  method isStyleLoaded

                                                                                                                                                                                                                                                                  isStyleLoaded: () => boolean;

                                                                                                                                                                                                                                                                    method isZooming

                                                                                                                                                                                                                                                                    isZooming: () => boolean;

                                                                                                                                                                                                                                                                      method jumpTo

                                                                                                                                                                                                                                                                      jumpTo: (
                                                                                                                                                                                                                                                                      options: mapboxgl.CameraOptions,
                                                                                                                                                                                                                                                                      eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                      ) => this;

                                                                                                                                                                                                                                                                        method listImages

                                                                                                                                                                                                                                                                        listImages: () => string[];

                                                                                                                                                                                                                                                                          method loaded

                                                                                                                                                                                                                                                                          loaded: () => boolean;

                                                                                                                                                                                                                                                                            method loadImage

                                                                                                                                                                                                                                                                            loadImage: (
                                                                                                                                                                                                                                                                            url: string,
                                                                                                                                                                                                                                                                            callback: (error?: Error, result?: HTMLImageElement | ImageBitmap) => void
                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                              method moveLayer

                                                                                                                                                                                                                                                                              moveLayer: (id: string, beforeId?: string) => this;

                                                                                                                                                                                                                                                                                method off

                                                                                                                                                                                                                                                                                off: {
                                                                                                                                                                                                                                                                                <T extends keyof MapLayerEventType>(
                                                                                                                                                                                                                                                                                type: T,
                                                                                                                                                                                                                                                                                layer: string | ReadonlyArray<string>,
                                                                                                                                                                                                                                                                                listener: (ev: MapLayerEventType[T] & EventData) => void
                                                                                                                                                                                                                                                                                ): this;
                                                                                                                                                                                                                                                                                <T extends keyof MapEventType>(
                                                                                                                                                                                                                                                                                type: T,
                                                                                                                                                                                                                                                                                listener: (ev: MapEventType[T] & EventData) => void
                                                                                                                                                                                                                                                                                ): this;
                                                                                                                                                                                                                                                                                (type: string, listener: (ev: any) => void): this;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  method on

                                                                                                                                                                                                                                                                                  on: {
                                                                                                                                                                                                                                                                                  <T extends keyof MapLayerEventType>(
                                                                                                                                                                                                                                                                                  type: T,
                                                                                                                                                                                                                                                                                  layer: string | ReadonlyArray<string>,
                                                                                                                                                                                                                                                                                  listener: (ev: MapLayerEventType[T] & EventData) => void
                                                                                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                                                                                  <T extends keyof MapEventType>(
                                                                                                                                                                                                                                                                                  type: T,
                                                                                                                                                                                                                                                                                  listener: (ev: MapEventType[T] & EventData) => void
                                                                                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                                                                                  (type: string, listener: (ev: any) => void): this;
                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                    method once

                                                                                                                                                                                                                                                                                    once: {
                                                                                                                                                                                                                                                                                    <T extends keyof MapLayerEventType>(
                                                                                                                                                                                                                                                                                    type: T,
                                                                                                                                                                                                                                                                                    layer: string | ReadonlyArray<string>,
                                                                                                                                                                                                                                                                                    listener: (ev: MapLayerEventType[T] & EventData) => void
                                                                                                                                                                                                                                                                                    ): this;
                                                                                                                                                                                                                                                                                    <T extends keyof MapEventType>(
                                                                                                                                                                                                                                                                                    type: T,
                                                                                                                                                                                                                                                                                    listener: (ev: MapEventType[T] & EventData) => void
                                                                                                                                                                                                                                                                                    ): this;
                                                                                                                                                                                                                                                                                    (type: string, listener: (ev: any) => void): this;
                                                                                                                                                                                                                                                                                    <T extends keyof MapEventType>(type: T): Promise<MapEventType[T]>;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      method panBy

                                                                                                                                                                                                                                                                                      panBy: (
                                                                                                                                                                                                                                                                                      offset: PointLike,
                                                                                                                                                                                                                                                                                      options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                      eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                      ) => this;

                                                                                                                                                                                                                                                                                        method panTo

                                                                                                                                                                                                                                                                                        panTo: (
                                                                                                                                                                                                                                                                                        lnglat: LngLatLike,
                                                                                                                                                                                                                                                                                        options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                        eventdata?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                        ) => this;

                                                                                                                                                                                                                                                                                          method project

                                                                                                                                                                                                                                                                                          project: (lnglat: LngLatLike) => Point;

                                                                                                                                                                                                                                                                                            method queryRenderedFeatures

                                                                                                                                                                                                                                                                                            queryRenderedFeatures: (
                                                                                                                                                                                                                                                                                            pointOrBox?: PointLike | [PointLike, PointLike],
                                                                                                                                                                                                                                                                                            options?: {
                                                                                                                                                                                                                                                                                            layers?: string[] | undefined;
                                                                                                                                                                                                                                                                                            filter?: any[] | undefined;
                                                                                                                                                                                                                                                                                            } & FilterOptions
                                                                                                                                                                                                                                                                                            ) => MapboxGeoJSONFeature[];
                                                                                                                                                                                                                                                                                            • Returns an array of GeoJSON Feature objects representing visible features that satisfy the query parameters.

                                                                                                                                                                                                                                                                                              The properties value of each returned feature object contains the properties of its source feature. For GeoJSON sources, only string and numeric property values are supported (i.e. null, Array, and Object values are not supported).

                                                                                                                                                                                                                                                                                              Each feature includes top-level layer, source, and sourceLayer properties. The layer property is an object representing the style layer to which the feature belongs. Layout and paint properties in this object contain values which are fully evaluated for the given zoom level and feature.

                                                                                                                                                                                                                                                                                              Only features that are currently rendered are included. Some features will not be included, like:

                                                                                                                                                                                                                                                                                              - Features from layers whose visibility property is "none". - Features from layers whose zoom range excludes the current zoom level. - Symbol features that have been hidden due to text or icon collision.

                                                                                                                                                                                                                                                                                              Features from all other layers are included, including features that may have no visible contribution to the rendered result; for example, because the layer's opacity or color alpha component is set to 0.

                                                                                                                                                                                                                                                                                              The topmost rendered feature appears first in the returned array, and subsequent features are sorted by descending z-order. Features that are rendered multiple times (due to wrapping across the antimeridian at low zoom levels) are returned only once (though subject to the following caveat).

                                                                                                                                                                                                                                                                                              Because features come from tiled vector data or GeoJSON data that is converted to tiles internally, feature geometries may be split or duplicated across tile boundaries and, as a result, features may appear multiple times in query results. For example, suppose there is a highway running through the bounding rectangle of a query. The results of the query will be those parts of the highway that lie within the map tiles covering the bounding rectangle, even if the highway extends into other tiles, and the portion of the highway within each map tile will be returned as a separate feature. Similarly, a point feature near a tile boundary may appear in multiple tiles due to tile buffering.

                                                                                                                                                                                                                                                                                              Parameter pointOrBox

                                                                                                                                                                                                                                                                                              The geometry of the query region: either a single point or southwest and northeast points describing a bounding box. Omitting this parameter (i.e. calling Map#queryRenderedFeatures with zero arguments, or with only a options argument) is equivalent to passing a bounding box encompassing the entire map viewport.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                            method querySourceFeatures

                                                                                                                                                                                                                                                                                            querySourceFeatures: (
                                                                                                                                                                                                                                                                                            sourceID: string,
                                                                                                                                                                                                                                                                                            parameters?: {
                                                                                                                                                                                                                                                                                            sourceLayer?: string | undefined;
                                                                                                                                                                                                                                                                                            filter?: any[] | undefined;
                                                                                                                                                                                                                                                                                            } & FilterOptions
                                                                                                                                                                                                                                                                                            ) => MapboxGeoJSONFeature[];
                                                                                                                                                                                                                                                                                            • Returns an array of GeoJSON Feature objects representing features within the specified vector tile or GeoJSON source that satisfy the query parameters.

                                                                                                                                                                                                                                                                                              In contrast to Map#queryRenderedFeatures, this function returns all features matching the query parameters, whether or not they are rendered by the current style (i.e. visible). The domain of the query includes all currently-loaded vector tiles and GeoJSON source tiles: this function does not check tiles outside the currently visible viewport.

                                                                                                                                                                                                                                                                                              Because features come from tiled vector data or GeoJSON data that is converted to tiles internally, feature geometries may be split or duplicated across tile boundaries and, as a result, features may appear multiple times in query results. For example, suppose there is a highway running through the bounding rectangle of a query. The results of the query will be those parts of the highway that lie within the map tiles covering the bounding rectangle, even if the highway extends into other tiles, and the portion of the highway within each map tile will be returned as a separate feature. Similarly, a point feature near a tile boundary may appear in multiple tiles due to tile buffering.

                                                                                                                                                                                                                                                                                              Parameter sourceID

                                                                                                                                                                                                                                                                                              The ID of the vector tile or GeoJSON source to query.

                                                                                                                                                                                                                                                                                              Parameter parameters

                                                                                                                                                                                                                                                                                            method queryTerrainElevation

                                                                                                                                                                                                                                                                                            queryTerrainElevation: (
                                                                                                                                                                                                                                                                                            lngLat: mapboxgl.LngLatLike,
                                                                                                                                                                                                                                                                                            options?: ElevationQueryOptions
                                                                                                                                                                                                                                                                                            ) => number | null;
                                                                                                                                                                                                                                                                                            • Parameter lngLat

                                                                                                                                                                                                                                                                                              The coordinate to query

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional {ElevationQueryOptions}

                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                              The elevation in meters at mean sea level or null

                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                            remove: () => void;

                                                                                                                                                                                                                                                                                              method removeControl

                                                                                                                                                                                                                                                                                              removeControl: (control: Control | IControl) => this;

                                                                                                                                                                                                                                                                                                method removeFeatureState

                                                                                                                                                                                                                                                                                                removeFeatureState: (
                                                                                                                                                                                                                                                                                                target: FeatureIdentifier | mapboxgl.MapboxGeoJSONFeature,
                                                                                                                                                                                                                                                                                                key?: string
                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                  method removeImage

                                                                                                                                                                                                                                                                                                  removeImage: (name: string) => void;

                                                                                                                                                                                                                                                                                                    method removeLayer

                                                                                                                                                                                                                                                                                                    removeLayer: (id: string) => this;

                                                                                                                                                                                                                                                                                                      method removeSource

                                                                                                                                                                                                                                                                                                      removeSource: (id: string) => this;

                                                                                                                                                                                                                                                                                                        method resetNorth

                                                                                                                                                                                                                                                                                                        resetNorth: (
                                                                                                                                                                                                                                                                                                        options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                                        eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                                        ) => this;

                                                                                                                                                                                                                                                                                                          method resetNorthPitch

                                                                                                                                                                                                                                                                                                          resetNorthPitch: (
                                                                                                                                                                                                                                                                                                          options?: mapboxgl.AnimationOptions | null,
                                                                                                                                                                                                                                                                                                          eventData?: mapboxgl.EventData | null
                                                                                                                                                                                                                                                                                                          ) => this;

                                                                                                                                                                                                                                                                                                            method resize

                                                                                                                                                                                                                                                                                                            resize: (eventData?: EventData) => this;

                                                                                                                                                                                                                                                                                                              method rotateTo

                                                                                                                                                                                                                                                                                                              rotateTo: (
                                                                                                                                                                                                                                                                                                              bearing: number,
                                                                                                                                                                                                                                                                                                              options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                                              eventData?: EventData
                                                                                                                                                                                                                                                                                                              ) => this;

                                                                                                                                                                                                                                                                                                                method setBearing

                                                                                                                                                                                                                                                                                                                setBearing: (bearing: number, eventData?: mapboxgl.EventData) => this;

                                                                                                                                                                                                                                                                                                                  method setCenter

                                                                                                                                                                                                                                                                                                                  setCenter: (center: LngLatLike, eventData?: mapboxgl.EventData) => this;

                                                                                                                                                                                                                                                                                                                    method setFeatureState

                                                                                                                                                                                                                                                                                                                    setFeatureState: (
                                                                                                                                                                                                                                                                                                                    feature: FeatureIdentifier | mapboxgl.MapboxGeoJSONFeature,
                                                                                                                                                                                                                                                                                                                    state: { [key: string]: any }
                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                      method setFilter

                                                                                                                                                                                                                                                                                                                      setFilter: (
                                                                                                                                                                                                                                                                                                                      layer: string,
                                                                                                                                                                                                                                                                                                                      filter?: any[] | boolean | null,
                                                                                                                                                                                                                                                                                                                      options?: FilterOptions | null
                                                                                                                                                                                                                                                                                                                      ) => this;

                                                                                                                                                                                                                                                                                                                        method setFog

                                                                                                                                                                                                                                                                                                                        setFog: (fog: Fog) => this;

                                                                                                                                                                                                                                                                                                                          method setFreeCameraOptions

                                                                                                                                                                                                                                                                                                                          setFreeCameraOptions: (options: FreeCameraOptions, eventData?: Object) => this;
                                                                                                                                                                                                                                                                                                                          • FreeCameraOptions provides more direct access to the underlying camera entity. For backwards compatibility the state set using this API must be representable with CameraOptions as well. Parameters are clamped into a valid range or discarded as invalid if the conversion to the pitch and bearing presentation is ambiguous. For example orientation can be invalid if it leads to the camera being upside down, the quaternion has zero length, or the pitch is over the maximum pitch limit.

                                                                                                                                                                                                                                                                                                                            Map#

                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                            FreeCameraOptions object

                                                                                                                                                                                                                                                                                                                            Parameter eventData

                                                                                                                                                                                                                                                                                                                            Additional properties to be added to event objects of events triggered by this method. movestart zoomstart pitchstart rotate move zoom pitch moveend zoomend pitchend

                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                            {Map} this

                                                                                                                                                                                                                                                                                                                          method setLayerZoomRange

                                                                                                                                                                                                                                                                                                                          setLayerZoomRange: (layerId: string, minzoom: number, maxzoom: number) => this;

                                                                                                                                                                                                                                                                                                                            method setLayoutProperty

                                                                                                                                                                                                                                                                                                                            setLayoutProperty: (
                                                                                                                                                                                                                                                                                                                            layer: string,
                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                            value: any,
                                                                                                                                                                                                                                                                                                                            options?: FilterOptions
                                                                                                                                                                                                                                                                                                                            ) => this;

                                                                                                                                                                                                                                                                                                                              method setLight

                                                                                                                                                                                                                                                                                                                              setLight: (light: mapboxgl.Light, options?: FilterOptions) => this;

                                                                                                                                                                                                                                                                                                                                method setMaxBounds

                                                                                                                                                                                                                                                                                                                                setMaxBounds: (lnglatbounds?: LngLatBoundsLike) => this;

                                                                                                                                                                                                                                                                                                                                  method setMaxPitch

                                                                                                                                                                                                                                                                                                                                  setMaxPitch: (maxPitch?: number | null) => this;

                                                                                                                                                                                                                                                                                                                                    method setMaxZoom

                                                                                                                                                                                                                                                                                                                                    setMaxZoom: (maxZoom?: number | null) => this;

                                                                                                                                                                                                                                                                                                                                      method setMinPitch

                                                                                                                                                                                                                                                                                                                                      setMinPitch: (minPitch?: number | null) => this;

                                                                                                                                                                                                                                                                                                                                        method setMinZoom

                                                                                                                                                                                                                                                                                                                                        setMinZoom: (minZoom?: number | null) => this;

                                                                                                                                                                                                                                                                                                                                          method setPadding

                                                                                                                                                                                                                                                                                                                                          setPadding: (padding: PaddingOptions, eventData?: EventData) => this;
                                                                                                                                                                                                                                                                                                                                          • Sets the padding in pixels around the viewport.

                                                                                                                                                                                                                                                                                                                                            Equivalent to jumpTo({padding: padding}).

                                                                                                                                                                                                                                                                                                                                            Map#

                                                                                                                                                                                                                                                                                                                                            Parameter padding

                                                                                                                                                                                                                                                                                                                                            The desired padding. Format: { left: number, right: number, top: number, bottom: number }

                                                                                                                                                                                                                                                                                                                                            Parameter eventData

                                                                                                                                                                                                                                                                                                                                            Additional properties to be added to event objects of events triggered by this method. movestart moveend

                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                            {Map} this

                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                            // Sets a left padding of 300px, and a top padding of 50px map.setPadding({ left: 300, top: 50 });

                                                                                                                                                                                                                                                                                                                                          method setPaintProperty

                                                                                                                                                                                                                                                                                                                                          setPaintProperty: (
                                                                                                                                                                                                                                                                                                                                          layer: string,
                                                                                                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                                                                                                          value: any,
                                                                                                                                                                                                                                                                                                                                          options?: FilterOptions
                                                                                                                                                                                                                                                                                                                                          ) => this;

                                                                                                                                                                                                                                                                                                                                            method setPitch

                                                                                                                                                                                                                                                                                                                                            setPitch: (pitch: number, eventData?: EventData) => this;

                                                                                                                                                                                                                                                                                                                                              method setRenderWorldCopies

                                                                                                                                                                                                                                                                                                                                              setRenderWorldCopies: (renderWorldCopies?: boolean) => this;

                                                                                                                                                                                                                                                                                                                                                method setStyle

                                                                                                                                                                                                                                                                                                                                                setStyle: (
                                                                                                                                                                                                                                                                                                                                                style: mapboxgl.Style | string,
                                                                                                                                                                                                                                                                                                                                                options?: {
                                                                                                                                                                                                                                                                                                                                                diff?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                localIdeographFontFamily?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                ) => this;

                                                                                                                                                                                                                                                                                                                                                  method setTerrain

                                                                                                                                                                                                                                                                                                                                                  setTerrain: (terrain?: TerrainSpecification | null) => this;
                                                                                                                                                                                                                                                                                                                                                  • Sets the terrain property of the style.

                                                                                                                                                                                                                                                                                                                                                    Parameter terrain

                                                                                                                                                                                                                                                                                                                                                    Terrain properties to set. Must conform to the [Mapbox Style Specification](https://www.mapbox.com/mapbox-gl-style-spec/#terrain). If null or undefined is provided, function removes terrain.

                                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                                    {Map} this

                                                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                                                    map.addSource('mapbox-dem', { 'type': 'raster-dem', 'url': 'mapbox://mapbox.mapbox-terrain-dem-v1', 'tileSize': 512, 'maxzoom': 14 }); // add the DEM source as a terrain layer with exaggerated height map.setTerrain({ 'source': 'mapbox-dem', 'exaggeration': 1.5 });

                                                                                                                                                                                                                                                                                                                                                  method setZoom

                                                                                                                                                                                                                                                                                                                                                  setZoom: (zoom: number, eventData?: mapboxgl.EventData) => this;

                                                                                                                                                                                                                                                                                                                                                    method snapToNorth

                                                                                                                                                                                                                                                                                                                                                    snapToNorth: (
                                                                                                                                                                                                                                                                                                                                                    options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                                                                                    eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                                                                                    ) => this;

                                                                                                                                                                                                                                                                                                                                                      method stop

                                                                                                                                                                                                                                                                                                                                                      stop: () => this;

                                                                                                                                                                                                                                                                                                                                                        method triggerRepaint

                                                                                                                                                                                                                                                                                                                                                        triggerRepaint: () => void;

                                                                                                                                                                                                                                                                                                                                                          method unproject

                                                                                                                                                                                                                                                                                                                                                          unproject: (point: PointLike) => LngLat;

                                                                                                                                                                                                                                                                                                                                                            method updateImage

                                                                                                                                                                                                                                                                                                                                                            updateImage: (
                                                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                                                            image:
                                                                                                                                                                                                                                                                                                                                                            | HTMLImageElement
                                                                                                                                                                                                                                                                                                                                                            | ArrayBufferView
                                                                                                                                                                                                                                                                                                                                                            | { width: number; height: number; data: Uint8Array | Uint8ClampedArray }
                                                                                                                                                                                                                                                                                                                                                            | ImageData
                                                                                                                                                                                                                                                                                                                                                            | ImageBitmap
                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                              method zoomIn

                                                                                                                                                                                                                                                                                                                                                              zoomIn: (
                                                                                                                                                                                                                                                                                                                                                              options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                                                                                              eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                                                                                              ) => this;

                                                                                                                                                                                                                                                                                                                                                                method zoomOut

                                                                                                                                                                                                                                                                                                                                                                zoomOut: (
                                                                                                                                                                                                                                                                                                                                                                options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                                                                                                eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                                                                                                ) => this;

                                                                                                                                                                                                                                                                                                                                                                  method zoomTo

                                                                                                                                                                                                                                                                                                                                                                  zoomTo: (
                                                                                                                                                                                                                                                                                                                                                                  zoom: number,
                                                                                                                                                                                                                                                                                                                                                                  options?: mapboxgl.AnimationOptions,
                                                                                                                                                                                                                                                                                                                                                                  eventData?: mapboxgl.EventData
                                                                                                                                                                                                                                                                                                                                                                  ) => this;

                                                                                                                                                                                                                                                                                                                                                                    class MapboxEvent

                                                                                                                                                                                                                                                                                                                                                                    class MapboxEvent<TOrig = undefined> {}

                                                                                                                                                                                                                                                                                                                                                                      property originalEvent

                                                                                                                                                                                                                                                                                                                                                                      originalEvent: {};

                                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                                        target: Map;

                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                                                                                                                            class MapMouseEvent

                                                                                                                                                                                                                                                                                                                                                                            class MapMouseEvent extends MapboxEvent<MouseEvent> {}

                                                                                                                                                                                                                                                                                                                                                                              property defaultPrevented

                                                                                                                                                                                                                                                                                                                                                                              defaultPrevented: boolean;

                                                                                                                                                                                                                                                                                                                                                                                property lngLat

                                                                                                                                                                                                                                                                                                                                                                                lngLat: LngLat;

                                                                                                                                                                                                                                                                                                                                                                                  property point

                                                                                                                                                                                                                                                                                                                                                                                  point: Point;

                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                    type:
                                                                                                                                                                                                                                                                                                                                                                                    | 'click'
                                                                                                                                                                                                                                                                                                                                                                                    | 'dblclick'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mousedown'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mouseup'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mousemove'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mouseenter'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mouseleave'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mouseover'
                                                                                                                                                                                                                                                                                                                                                                                    | 'mouseout'
                                                                                                                                                                                                                                                                                                                                                                                    | 'contextmenu';

                                                                                                                                                                                                                                                                                                                                                                                      method preventDefault

                                                                                                                                                                                                                                                                                                                                                                                      preventDefault: () => void;

                                                                                                                                                                                                                                                                                                                                                                                        class MapTouchEvent

                                                                                                                                                                                                                                                                                                                                                                                        class MapTouchEvent extends MapboxEvent<TouchEvent> {}

                                                                                                                                                                                                                                                                                                                                                                                          property defaultPrevented

                                                                                                                                                                                                                                                                                                                                                                                          defaultPrevented: boolean;

                                                                                                                                                                                                                                                                                                                                                                                            property lngLat

                                                                                                                                                                                                                                                                                                                                                                                            lngLat: LngLat;

                                                                                                                                                                                                                                                                                                                                                                                              property lngLats

                                                                                                                                                                                                                                                                                                                                                                                              lngLats: LngLat[];

                                                                                                                                                                                                                                                                                                                                                                                                property point

                                                                                                                                                                                                                                                                                                                                                                                                point: Point;

                                                                                                                                                                                                                                                                                                                                                                                                  property points

                                                                                                                                                                                                                                                                                                                                                                                                  points: Point[];

                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                    type: 'touchstart' | 'touchend' | 'touchcancel';

                                                                                                                                                                                                                                                                                                                                                                                                      method preventDefault

                                                                                                                                                                                                                                                                                                                                                                                                      preventDefault: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                        class MapWheelEvent

                                                                                                                                                                                                                                                                                                                                                                                                        class MapWheelEvent extends MapboxEvent<WheelEvent> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property defaultPrevented

                                                                                                                                                                                                                                                                                                                                                                                                          defaultPrevented: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                              method preventDefault

                                                                                                                                                                                                                                                                                                                                                                                                              preventDefault: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                class Marker

                                                                                                                                                                                                                                                                                                                                                                                                                class Marker extends Evented {}
                                                                                                                                                                                                                                                                                                                                                                                                                • Marker

                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                constructor(options?: MarkerOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(element?: HTMLElement, options?: MarkerOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                    method addTo

                                                                                                                                                                                                                                                                                                                                                                                                                    addTo: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                      method getElement

                                                                                                                                                                                                                                                                                                                                                                                                                      getElement: () => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                        method getLngLat

                                                                                                                                                                                                                                                                                                                                                                                                                        getLngLat: () => LngLat;

                                                                                                                                                                                                                                                                                                                                                                                                                          method getOffset

                                                                                                                                                                                                                                                                                                                                                                                                                          getOffset: () => PointLike;

                                                                                                                                                                                                                                                                                                                                                                                                                            method getPitchAlignment

                                                                                                                                                                                                                                                                                                                                                                                                                            getPitchAlignment: () => Alignment;

                                                                                                                                                                                                                                                                                                                                                                                                                              method getPopup

                                                                                                                                                                                                                                                                                                                                                                                                                              getPopup: () => Popup;

                                                                                                                                                                                                                                                                                                                                                                                                                                method getRotation

                                                                                                                                                                                                                                                                                                                                                                                                                                getRotation: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getRotationAlignment

                                                                                                                                                                                                                                                                                                                                                                                                                                  getRotationAlignment: () => Alignment;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDraggable

                                                                                                                                                                                                                                                                                                                                                                                                                                    isDraggable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                      remove: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method setDraggable

                                                                                                                                                                                                                                                                                                                                                                                                                                        setDraggable: (shouldBeDraggable: boolean) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method setLngLat

                                                                                                                                                                                                                                                                                                                                                                                                                                          setLngLat: (lngLat: LngLatLike) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method setOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                            setOffset: (offset: PointLike) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method setPitchAlignment

                                                                                                                                                                                                                                                                                                                                                                                                                                              setPitchAlignment: (alignment: Alignment) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method setPopup

                                                                                                                                                                                                                                                                                                                                                                                                                                                setPopup: (popup?: Popup) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setRotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                  setRotation: (rotation: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setRotationAlignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                    setRotationAlignment: (alignment: Alignment) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method togglePopup

                                                                                                                                                                                                                                                                                                                                                                                                                                                      togglePopup: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MercatorCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MercatorCoordinate {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • MercatorCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(x: number, y: number, z?: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                          x: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The x component of the position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                          y: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The y component of the position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                          z?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The z component of the position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            0

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method fromLngLat

                                                                                                                                                                                                                                                                                                                                                                                                                                                          static fromLngLat: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          lngLatLike: LngLatLike,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          altitude?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => MercatorCoordinate;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Project a LngLat to a MercatorCoordinate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method meterInMercatorCoordinateUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                          meterInMercatorCoordinateUnits: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the distance of 1 meter in MercatorCoordinate units at this latitude.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            For coordinates in real world units using meters, this naturally provides the scale to transform into MercatorCoordinates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toAltitude

                                                                                                                                                                                                                                                                                                                                                                                                                                                          toAltitude: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the altitude in meters of the coordinate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toLngLat

                                                                                                                                                                                                                                                                                                                                                                                                                                                          toLngLat: () => LngLat;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the LngLat for the coordinate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class NavigationControl extends Control {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Navigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          showCompass?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          showZoom?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          visualizePitch?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          });

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Point {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(x: number, y: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                              x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  add: (p: Point) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method angle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    angle: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method angleTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      angleTo: (p: Point) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method angleWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        angleWidth: (p: Point) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method angleWithSep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          angleWithSep: (x: number, y: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            clone: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method convert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static convert: (a: PointLike) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method dist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dist: (p: Point) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method distSqr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  distSqr: (p: Point) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    div: (k: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      equals: (p: Point) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method mag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mag: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method matMult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          matMult: (m: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method mult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mult: (k: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method perp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              perp: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method rotate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rotate: (a: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method round

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  round: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sub: (p: Point) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unit: () => Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Popup extends Evented {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Popup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(options?: PopupOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method addClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addClassName: (className: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Adds a CSS class to the popup container element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Non-empty string with CSS class name to add to popup container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let popup = new mapboxgl.Popup() popup.addClassName('some-class')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method addTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addTo: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getElement: () => HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Returns the Popup's HTML element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getLngLat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getLngLat: () => LngLat;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getMaxWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMaxWidth: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isOpen: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remove: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method removeClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeClassName: (className: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Removes a CSS class from the popup container element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Non-empty string with CSS class name to remove from popup container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let popup = new mapboxgl.Popup() popup.removeClassName('some-class')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setDOMContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setDOMContent: (htmlNode: Node) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setHTML: (html: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setLngLat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setLngLat: (lnglat: LngLatLike) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Sets the geographical location of the popup's anchor, and moves the popup to it. Replaces trackPointer() behavior.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter lnglat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The geographical location to set as the popup's anchor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setMaxWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setMaxWidth: (maxWidth: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setOffset: (offset?: Offset | null) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Sets the popup's offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets the popup's offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {Popup} this

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setText: (text: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toggleClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toggleClassName: (className: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Add or remove the given CSS class on the popup container, depending on whether the container currently has that class.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Non-empty string with CSS class name to add/remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {boolean} if the class was removed return false, if class was added, then return true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              let popup = new mapboxgl.Popup() popup.toggleClassName('toggleClass')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method trackPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            trackPointer: () => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Tracks the popup anchor to the cursor position, on screens with a pointer device (will be hidden on touchscreens). Replaces the setLngLat behavior. For most use cases, closeOnClick and closeButton should also be set to false here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PositionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PositionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property enableHighAccuracy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enableHighAccuracy?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maximumAge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maximumAge?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScaleControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScaleControl extends Control {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxWidth?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unit?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setUnit: (unit: 'imperial' | 'metric' | 'nautical') => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ScrollZoomHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ScrollZoomHandler {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • ScrollZoomHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(map: Map);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disable: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enable: (options?: InteractiveOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setWheelZoomRate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setWheelZoomRate: (wheelZoomRate: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setZoomRate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setZoomRate: (zoomRate: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TouchPitchHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TouchPitchHandler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(map: Map);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disable: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enable: (options?: InteractiveOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isActive: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TouchZoomRotateHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TouchZoomRotateHandler {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • TouchZoomRotateHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(map: Map);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method disable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  disable: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method disableRotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disableRotation: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enable: (options?: InteractiveOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method enableRotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enableRotation: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class VideoSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class VideoSource implements VideoSourceRaw {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(options?: VideoSourceOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getVideo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getVideo: () => HTMLVideoElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setCoordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setCoordinates: (coordinates: number[][]) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface AnimationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface AnimationOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • AnimationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property animate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      animate?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • When set to false, no animation happens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      duration?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Number in milliseconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property easing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      easing?: ((time: number) => number) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A function taking a time in the range 0..1 and returning a number where 0 is the initial state and 1 is the final state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property essential

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      essential?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • If true, then the animation is considered essential and will not be affected by prefers-reduced-motion. Otherwise, the transition will happen instantly if the user has enabled the reduced motion accesibility feature in their operating system.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset?: PointLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • point, origin of movement relative to map center

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BackgroundLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BackgroundLayer extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        layout?: BackgroundLayout | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property paint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          paint?: BackgroundPaint | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'background';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface BackgroundLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface BackgroundLayout extends Layout {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface BackgroundPaint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface BackgroundPaint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'background-color-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'background-color-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'background-color'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'background-color'?: string | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'background-opacity-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'background-opacity-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'background-opacity'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'background-opacity'?: number | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'background-pattern-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'background-pattern-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'background-pattern'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'background-pattern'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CameraForBoundsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CameraForBoundsOptions extends CameraOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maxZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxZoom?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offset?: PointLike | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CameraOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CameraOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CameraOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property around

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    around?: LngLatLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If zooming, the zoom center (defaults to map center)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bearing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bearing?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Map rotation bearing in degrees counter-clockwise from north

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property center

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    center?: LngLatLike | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Map center

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property padding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    padding?: number | PaddingOptions | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Dimensions in pixels applied on each side of the viewport for shifting the vanishing point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pitch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pitch?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Map angle in degrees at which the camera is looking at the ground

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property zoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zoom?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Map zoom level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CanonicalCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CanonicalCoordinate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            z: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              equals: (coord: CanonicalCoordinate) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CanvasSourceOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CanvasSourceOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property animate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  animate?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property canvas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    canvas: string | HTMLCanvasElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property coordinates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      coordinates: number[][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CanvasSourceRaw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CanvasSourceRaw extends Source, CanvasSourceOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • CanvasSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'canvas';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CircleLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CircleLayer extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            layout?: CircleLayout | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property paint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              paint?: CirclePaint | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'circle';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CircleLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CircleLayout extends Layout {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'circle-sort-key'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'circle-sort-key'?: number | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CirclePaint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CirclePaint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'circle-blur-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'circle-blur-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'circle-blur'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'circle-blur'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'circle-color-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'circle-color-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 'circle-color'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'circle-color'?: string | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'circle-opacity-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'circle-opacity-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'circle-opacity'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'circle-opacity'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'circle-pitch-alignment'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'circle-pitch-alignment'?: 'map' | 'viewport' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'circle-pitch-scale'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'circle-pitch-scale'?: 'map' | 'viewport' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'circle-radius-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'circle-radius-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'circle-radius'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'circle-radius'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'circle-stroke-color-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'circle-stroke-color-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 'circle-stroke-color'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'circle-stroke-color'?: string | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'circle-stroke-opacity-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'circle-stroke-opacity-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'circle-stroke-opacity'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'circle-stroke-opacity'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'circle-stroke-width-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'circle-stroke-width-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'circle-stroke-width'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'circle-stroke-width'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'circle-translate-anchor'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'circle-translate-anchor'?: 'map' | 'viewport' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'circle-translate-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'circle-translate-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'circle-translate'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'circle-translate'?: number[] | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Coordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Coordinate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property canonical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                canonical: CanonicalCoordinate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    wrap: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomLayerInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomLayerInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A unique layer id.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property renderingMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderingMode?: '2d' | '3d' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'custom';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onAdd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onAdd: (map: Map, gl: WebGLRenderingContext) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional method called when the layer has been added to the Map with Map#addLayer. This gives the layer a chance to initialize gl resources and register event listeners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The Map this custom layer was just added to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter gl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The gl context for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onRemove: (map: Map, gl: WebGLRenderingContext) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional method called when the layer has been removed from the Map with Map#removeLayer. This gives the layer a chance to clean up gl resources and event listeners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The Map this custom layer was just added to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter gl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The gl context for the map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method prerender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prerender: (gl: WebGLRenderingContext, matrix: number[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Optional method called during a render frame to allow a layer to prepare resources or render into a texture.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The layer cannot make any assumptions about the current GL state and must bind a framebuffer before rendering.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter gl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The map's gl context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter matrix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The map's camera matrix. It projects spherical mercator coordinates to gl coordinates. The mercator coordinate [0, 0] represents the top left corner of the mercator world and [1, 1] represents the bottom right corner. When the renderingMode is "3d" , the z coordinate is conformal. A box with identical x, y, and z lengths in mercator units would be rendered as a cube. MercatorCoordinate .fromLatLng can be used to project a LngLat to a mercator coordinate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: (gl: WebGLRenderingContext, matrix: number[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Called during a render frame allowing the layer to draw into the GL context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The layer can assume blending and depth state is set to allow the layer to properly blend and clip other layers. The layer cannot make any other assumptions about the current GL state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              If the layer needs to render to a texture, it should implement the prerender method to do this and only use the render method for drawing directly into the main framebuffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The blend function is set to gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA). This expects colors to be provided in premultiplied alpha form where the r, g and b values are already multiplied by the a value. If you are unable to provide colors in premultiplied form you may want to change the blend function to gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter gl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The map's gl context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter matrix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The map's camera matrix. It projects spherical mercator coordinates to gl coordinates. The mercator coordinate [0, 0] represents the top left corner of the mercator world and [1, 1] represents the bottom right corner. When the renderingMode is "3d" , the z coordinate is conformal. A box with identical x, y, and z lengths in mercator units would be rendered as a cube. MercatorCoordinate .fromLatLng can be used to project a LngLat to a mercator coordinate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CustomSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CustomSource<T> extends Source {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property attribution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              attribution: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property maxzoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxzoom: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property minzoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minzoom: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scheme: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tileSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tileSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'custom';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CustomSourceInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CustomSourceInterface<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property attribution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              attribution?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bounds?: [number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dataType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dataType: 'raster';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasTile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hasTile?: (tileID: { z: number; x: number; y: number }) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loadTile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loadTile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tileID: { z: number; x: number; y: number },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: { signal: AbortSignal }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property maxzoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxzoom?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property minzoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            minzoom?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onAdd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onAdd?: (map: Map) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onRemove?: (map: Map) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property prepareTile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prepareTile?: (tileID: { z: number; x: number; y: number }) => T | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property scheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scheme?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tileSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tileSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'custom';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property unloadTile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unloadTile?: (tileID: { z: number; x: number; y: number }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface EaseToOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface EaseToOptions extends AnimationOptions, CameraOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • EaseToOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property delayEndEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            delayEndEvents?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FeatureIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FeatureIdentifier {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: string | number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sourceLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceLayer?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FillExtrusionLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FillExtrusionLayer extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        layout?: FillExtrusionLayout | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property paint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          paint?: FillExtrusionPaint | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'fill-extrusion';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FillExtrusionLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FillExtrusionLayout extends Layout {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FillExtrusionPaint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FillExtrusionPaint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'fill-extrusion-base-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'fill-extrusion-base-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'fill-extrusion-base'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'fill-extrusion-base'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'fill-extrusion-color-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'fill-extrusion-color-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'fill-extrusion-color'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'fill-extrusion-color'?: string | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'fill-extrusion-height-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'fill-extrusion-height-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'fill-extrusion-height'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'fill-extrusion-height'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 'fill-extrusion-opacity-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'fill-extrusion-opacity-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'fill-extrusion-opacity'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'fill-extrusion-opacity'?: number | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'fill-extrusion-pattern-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'fill-extrusion-pattern-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'fill-extrusion-pattern'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'fill-extrusion-pattern'?: string | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'fill-extrusion-translate-anchor'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'fill-extrusion-translate-anchor'?: 'map' | 'viewport' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'fill-extrusion-translate-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'fill-extrusion-translate-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'fill-extrusion-translate'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'fill-extrusion-translate'?: number[] | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'fill-extrusion-vertical-gradient'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'fill-extrusion-vertical-gradient'?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FillLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FillLayer extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                layout?: FillLayout | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property paint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paint?: FillPaint | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'fill';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FillLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FillLayout extends Layout {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'fill-sort-key'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'fill-sort-key'?: number | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FillPaint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FillPaint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'fill-antialias'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'fill-antialias'?: boolean | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 'fill-color-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'fill-color-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'fill-color'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'fill-color'?: string | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'fill-opacity-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'fill-opacity-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'fill-opacity'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'fill-opacity'?: number | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'fill-outline-color-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'fill-outline-color-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'fill-outline-color'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'fill-outline-color'?: string | StyleFunction | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'fill-pattern-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'fill-pattern-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'fill-pattern'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'fill-pattern'?: string | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 'fill-translate-anchor'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'fill-translate-anchor'?: 'map' | 'viewport' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'fill-translate-transition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'fill-translate-transition'?: Transition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'fill-translate'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'fill-translate'?: number[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FilterOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FilterOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • FilterOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    validate?: boolean | null | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Whether to check if the filter conforms to the Mapbox GL Style Specification. Disabling validation is a performance optimization that should only be used if you have previously validated the values you will be passing to this function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FitBoundsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FitBoundsOptions extends mapboxgl.FlyToOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property linear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      linear?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        maxDuration?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property maxZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxZoom?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            offset?: mapboxgl.PointLike | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FlyToOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FlyToOptions extends AnimationOptions, CameraOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • FlyToOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property curve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              curve?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maxDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxDuration?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minZoom?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property screenSpeed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    screenSpeed?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property speed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      speed?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Fog

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Fog {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'horizon-blend'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'horizon-blend'?: number | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: string | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              range?: number[] | Expression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FullscreenControlOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FullscreenControlOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  container?: HTMLElement | null | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A compatible DOM element which should be made full screen. By default, the map container element will be made full screen.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GeoJSONSourceOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GeoJSONSourceOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property attribution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    attribution?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buffer?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cluster

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cluster?: number | boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property clusterMaxZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          clusterMaxZoom?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property clusterMinPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            clusterMinPoints?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Minimum number of points necessary to form a cluster if clustering is enabled. Defaults to 2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property clusterProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            clusterProperties?: object | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property clusterRadius

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clusterRadius?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | GeoJSON.Feature<GeoJSON.Geometry>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | GeoJSON.FeatureCollection<GeoJSON.Geometry>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | GeoJSON.Geometry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filter?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property generateId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    generateId?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lineMetrics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lineMetrics?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxzoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        maxzoom?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property promoteId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          promoteId?: PromoteIdSpecification | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tolerance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tolerance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GeoJSONSourceRaw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface GeoJSONSourceRaw extends Source, GeoJSONSourceOptions {