@types/leaflet

  • Version 1.7.4
  • Published
  • 79.6 kB
  • 1 dependency
  • MIT license

Install

npm i @types/leaflet
yarn add @types/leaflet
pnpm add @types/leaflet

Overview

TypeScript definitions for Leaflet.js

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable bind

const bind: (fn: (...args: any[]) => void, ...obj: any[]) => () => void;

    variable extend

    const extend: {
    <D extends object, S1 extends object = {}>(dest: D, src?: S1): D & S1;
    <D extends object, S1 extends object, S2 extends object>(
    dest: D,
    src1: S1,
    src2: S2
    ): D & S1 & S2;
    <D extends object, S1 extends object, S2 extends object, S3 extends object>(
    dest: D,
    src1: S1,
    src2: S2,
    src3: S3
    ): D & S1 & S2 & S3;
    (dest: any, ...src: any[]): any;
    };

      variable setOptions

      const setOptions: (obj: any, options: any) => any;

        variable stamp

        const stamp: (obj: any) => number;

          variable version

          const version: string;
          • A constant that represents the Leaflet version in use.

          Functions

          function bounds

          bounds: {
          (topLeft: PointExpression, bottomRight: PointExpression): Bounds;
          (points: Point[] | BoundsLiteral): Bounds;
          };

            function canvas

            canvas: (options?: RendererOptions) => Canvas;

              function circle

              circle: {
              (latlng: LatLngExpression, options?: CircleMarkerOptions): Circle;
              (
              latlng: LatLngExpression,
              radius: number,
              options?: CircleMarkerOptions
              ): Circle<any>;
              };

                function circleMarker

                circleMarker: (
                latlng: LatLngExpression,
                options?: CircleMarkerOptions
                ) => CircleMarker;

                  function divIcon

                  divIcon: (options?: DivIconOptions) => DivIcon;

                    function featureGroup

                    featureGroup: (layers?: Layer[], options?: LayerOptions) => FeatureGroup;
                    • Create a feature group, optionally given an initial set of layers.

                    function geoJSON

                    geoJSON: <P = any>(geojson?: any, options?: GeoJSONOptions<P>) => GeoJSON<P>;
                    • Creates a GeoJSON layer.

                      Optionally accepts an object in GeoJSON format to display on the map (you can alternatively add it later with addData method) and an options object.

                    function gridLayer

                    gridLayer: (options?: GridLayerOptions) => GridLayer;

                      function icon

                      icon: (options: IconOptions) => Icon;

                        function imageOverlay

                        imageOverlay: (
                        imageUrl: string,
                        bounds: LatLngBoundsExpression,
                        options?: ImageOverlayOptions
                        ) => ImageOverlay;

                          function latLng

                          latLng: {
                          (latitude: number, longitude: number, altitude?: number): LatLng;
                          (
                          coords:
                          | LatLngTuple
                          | [number, number, number]
                          | LatLngLiteral
                          | { lat: number; lng: number; alt?: number }
                          ): LatLng;
                          };

                            function latLngBounds

                            latLngBounds: {
                            (southWest: LatLngExpression, northEast: LatLngExpression): LatLngBounds;
                            (latlngs: LatLngExpression[]): LatLngBounds;
                            };

                              function layerGroup

                              layerGroup: (layers?: Layer[], options?: LayerOptions) => LayerGroup;
                              • Create a layer group, optionally given an initial set of layers and an options object.

                              function map

                              map: (element: string | HTMLElement, options?: MapOptions) => Map;
                              • ID of a HTML-Element as string or the HTML-ELement itself

                              function marker

                              marker: (latlng: LatLngExpression, options?: MarkerOptions) => Marker;

                                function point

                                point: {
                                (x: number, y: number, round?: boolean): Point;
                                (coords: PointTuple | { x: number; y: number }): Point;
                                };

                                  function polygon

                                  polygon: (
                                  latlngs: LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][],
                                  options?: PolylineOptions
                                  ) => Polygon;

                                    function polyline

                                    polyline: (
                                    latlngs: LatLngExpression[] | LatLngExpression[][],
                                    options?: PolylineOptions
                                    ) => Polyline;
                                      popup: (options?: PopupOptions, source?: Layer) => Popup;

                                        function rectangle

                                        rectangle: (
                                        latLngBounds: LatLngBoundsExpression,
                                        options?: PolylineOptions
                                        ) => Rectangle;

                                          function svg

                                          svg: (options?: RendererOptions) => SVG;

                                            function svgOverlay

                                            svgOverlay: (
                                            svgImage: string | SVGElement,
                                            bounds: LatLngBoundsExpression,
                                            options?: ImageOverlayOptions
                                            ) => SVGOverlay;

                                              function tileLayer

                                              tileLayer: typeof tileLayer;

                                                function tooltip

                                                tooltip: (options?: TooltipOptions, source?: Layer) => Tooltip;

                                                  function transformation

                                                  transformation: {
                                                  (a: number, b: number, c: number, d: number): Transformation;
                                                  (coefficients: [number, number, number, number]): Transformation;
                                                  };
                                                  • Instantiates a Transformation object with the given coefficients.

                                                  • Expects an coefficients array of the form [a: Number, b: Number, c: Number, d: Number].

                                                  function videoOverlay

                                                  videoOverlay: (
                                                  video: string | string[] | HTMLVideoElement,
                                                  bounds: LatLngBoundsExpression,
                                                  options?: VideoOverlayOptions
                                                  ) => VideoOverlay;

                                                    Classes

                                                    class Bounds

                                                    class Bounds {}

                                                      constructor

                                                      constructor(topLeft: PointExpression, bottomRight: PointExpression);

                                                        constructor

                                                        constructor(points: Point[] | BoundsLiteral);

                                                          property max

                                                          max?: Point;

                                                            property min

                                                            min?: Point;

                                                              method contains

                                                              contains: (pointOrBounds: BoundsExpression | PointExpression) => boolean;

                                                                method extend

                                                                extend: (point: PointExpression) => this;

                                                                  method getBottomLeft

                                                                  getBottomLeft: () => Point;

                                                                    method getBottomRight

                                                                    getBottomRight: () => Point;

                                                                      method getCenter

                                                                      getCenter: (round?: boolean) => Point;

                                                                        method getSize

                                                                        getSize: () => Point;

                                                                          method getTopLeft

                                                                          getTopLeft: () => Point;

                                                                            method getTopRight

                                                                            getTopRight: () => Point;

                                                                              method intersects

                                                                              intersects: (otherBounds: BoundsExpression) => boolean;

                                                                                method overlaps

                                                                                overlaps: (otherBounds: BoundsExpression) => boolean;

                                                                                  class Canvas

                                                                                  class Canvas extends Renderer {}

                                                                                    class Circle

                                                                                    class Circle<P = any> extends CircleMarker<P> {}

                                                                                      constructor

                                                                                      constructor(latlng: LatLngExpression, options?: CircleMarkerOptions);

                                                                                        constructor

                                                                                        constructor(
                                                                                        latlng: LatLngExpression,
                                                                                        radius: number,
                                                                                        options?: CircleMarkerOptions
                                                                                        );

                                                                                          method getBounds

                                                                                          getBounds: () => LatLngBounds;

                                                                                            class CircleMarker

                                                                                            class CircleMarker<P = any> extends Path {}

                                                                                              constructor

                                                                                              constructor(latlng: LatLngExpression, options?: CircleMarkerOptions);

                                                                                                property feature

                                                                                                feature?: any;

                                                                                                  property options

                                                                                                  options: CircleMarkerOptions;

                                                                                                    method getLatLng

                                                                                                    getLatLng: () => LatLng;

                                                                                                      method getRadius

                                                                                                      getRadius: () => number;

                                                                                                        method setLatLng

                                                                                                        setLatLng: (latLng: LatLngExpression) => this;

                                                                                                          method setRadius

                                                                                                          setRadius: (radius: number) => this;

                                                                                                            method toGeoJSON

                                                                                                            toGeoJSON: (precision?: number) => any;

                                                                                                              class Class

                                                                                                              class Class {}

                                                                                                                method addInitHook

                                                                                                                static addInitHook: {
                                                                                                                (initHookFn: () => void): any & typeof Class;
                                                                                                                (methodName: string, ...args: any[]): any;
                                                                                                                };

                                                                                                                  method extend

                                                                                                                  static extend: (props: any) => (new (...args: any[]) => any) & typeof Class;

                                                                                                                    method include

                                                                                                                    static include: (props: any) => any & typeof Class;

                                                                                                                      method mergeOptions

                                                                                                                      static mergeOptions: (props: any) => any & typeof Class;

                                                                                                                        class Control

                                                                                                                        class Control extends Class {}

                                                                                                                          constructor

                                                                                                                          constructor(options?: ControlOptions);

                                                                                                                            property options

                                                                                                                            options: ControlOptions;

                                                                                                                              method addTo

                                                                                                                              addTo: (map: Map) => this;

                                                                                                                                method extend

                                                                                                                                static extend: <T extends object>(
                                                                                                                                props: T
                                                                                                                                ) => (new (...args: any[]) => T) & typeof Control;

                                                                                                                                  method getContainer

                                                                                                                                  getContainer: () => HTMLElement | undefined;

                                                                                                                                    method getPosition

                                                                                                                                    getPosition: () => ControlPosition;

                                                                                                                                      method onAdd

                                                                                                                                      onAdd: (map: Map) => HTMLElement;

                                                                                                                                        method onRemove

                                                                                                                                        onRemove: (map: Map) => void;

                                                                                                                                          method remove

                                                                                                                                          remove: () => this;

                                                                                                                                            method setPosition

                                                                                                                                            setPosition: (position: ControlPosition) => this;

                                                                                                                                              class DivIcon

                                                                                                                                              class DivIcon extends Icon<DivIconOptions> {}

                                                                                                                                                constructor

                                                                                                                                                constructor(options?: DivIconOptions);

                                                                                                                                                  class DivOverlay

                                                                                                                                                  abstract class DivOverlay extends Layer {}

                                                                                                                                                    constructor

                                                                                                                                                    constructor(options?: DivOverlayOptions, source?: Layer);

                                                                                                                                                      property options

                                                                                                                                                      options: DivOverlayOptions;

                                                                                                                                                        method bringToBack

                                                                                                                                                        bringToBack: () => this;

                                                                                                                                                          method bringToFront

                                                                                                                                                          bringToFront: () => this;

                                                                                                                                                            method getContent

                                                                                                                                                            getContent: () => Content | ((source: Layer) => Content);

                                                                                                                                                              method getElement

                                                                                                                                                              getElement: () => HTMLElement | undefined;

                                                                                                                                                                method getLatLng

                                                                                                                                                                getLatLng: () => LatLng | undefined;

                                                                                                                                                                  method isOpen

                                                                                                                                                                  isOpen: () => boolean;

                                                                                                                                                                    method setContent

                                                                                                                                                                    setContent: (htmlContent: Content | ((source: Layer) => Content)) => this;

                                                                                                                                                                      method setLatLng

                                                                                                                                                                      setLatLng: (latlng: LatLngExpression) => this;

                                                                                                                                                                        method update

                                                                                                                                                                        update: () => void;

                                                                                                                                                                          class Draggable

                                                                                                                                                                          class Draggable extends Evented {}
                                                                                                                                                                          • A class for making DOM elements draggable (including touch support). Used internally for map and marker dragging. Only works for elements that were positioned with [L.DomUtil.setPosition](#domutil-setposition).

                                                                                                                                                                          constructor

                                                                                                                                                                          constructor(
                                                                                                                                                                          element: HTMLElement,
                                                                                                                                                                          dragStartTarget?: HTMLElement,
                                                                                                                                                                          preventOutline?: boolean
                                                                                                                                                                          );

                                                                                                                                                                            method disable

                                                                                                                                                                            disable: () => void;

                                                                                                                                                                              method enable

                                                                                                                                                                              enable: () => void;

                                                                                                                                                                                method finishDrag

                                                                                                                                                                                finishDrag: () => void;

                                                                                                                                                                                  class Evented

                                                                                                                                                                                  abstract class Evented extends Class {}
                                                                                                                                                                                  • A set of methods shared between event-powered classes (like Map and Marker). Generally, events allow you to execute some function when something happens with an object (e.g. the user clicks on the map, causing the map to fire 'click' event).

                                                                                                                                                                                  method addEventListener

                                                                                                                                                                                  addEventListener: {
                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                  fn: LayersControlEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                  fn: LayerEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                  | 'load'
                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                  | 'move'
                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                  | 'add'
                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                  | 'error'
                                                                                                                                                                                  | 'update'
                                                                                                                                                                                  | 'down'
                                                                                                                                                                                  | 'predrag',
                                                                                                                                                                                  fn: LeafletEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'resize', fn: ResizeEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                  fn: PopupEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                  fn: TooltipEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'locationerror', fn: ErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'locationfound', fn: LocationEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'click'
                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                  fn: LeafletMouseEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                  fn: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'zoomanim', fn: ZoomAnimEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'dragend', fn: DragEndEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload',
                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                  };
                                                                                                                                                                                  • Alias for on(...)

                                                                                                                                                                                    Adds a listener function (fn) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. 'click dblclick').

                                                                                                                                                                                  • Alias for on(...)

                                                                                                                                                                                    Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove}

                                                                                                                                                                                  method addEventParent

                                                                                                                                                                                  addEventParent: (obj: Evented) => this;
                                                                                                                                                                                  • Adds an event parent - an Evented that will receive propagated events

                                                                                                                                                                                  method addOneTimeEventListener

                                                                                                                                                                                  addOneTimeEventListener: {
                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                  fn: LayersControlEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                  fn: LayerEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                  | 'load'
                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                  | 'move'
                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                  | 'add'
                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                  | 'error'
                                                                                                                                                                                  | 'update'
                                                                                                                                                                                  | 'down'
                                                                                                                                                                                  | 'predrag',
                                                                                                                                                                                  fn: LeafletEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'resize', fn: ResizeEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                  fn: PopupEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                  fn: TooltipEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'locationerror', fn: ErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'locationfound', fn: LocationEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'click'
                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                  fn: LeafletMouseEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                  fn: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'zoomanim', fn: ZoomAnimEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'dragend', fn: DragEndEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload',
                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                  };
                                                                                                                                                                                  • Alias for once(...)

                                                                                                                                                                                    Behaves as on(...), except the listener will only get fired once and then removed.

                                                                                                                                                                                  method clearAllEventListeners

                                                                                                                                                                                  clearAllEventListeners: () => this;
                                                                                                                                                                                  • Alias for off()

                                                                                                                                                                                    Removes all listeners to all events on the object.

                                                                                                                                                                                  method fire

                                                                                                                                                                                  fire: (type: string, data?: any, propagate?: boolean) => this;
                                                                                                                                                                                  • Fires an event of the specified type. You can optionally provide a data object — the first argument of the listener function will contain its properties. The event might can optionally be propagated to event parents.

                                                                                                                                                                                  method fireEvent

                                                                                                                                                                                  fireEvent: (type: string, data?: any, propagate?: boolean) => this;
                                                                                                                                                                                  • Alias for fire(...)

                                                                                                                                                                                    Fires an event of the specified type. You can optionally provide a data object — the first argument of the listener function will contain its properties. The event might can optionally be propagated to event parents.

                                                                                                                                                                                  method hasEventListeners

                                                                                                                                                                                  hasEventListeners: (type: string) => boolean;
                                                                                                                                                                                  • Alias for listens(...)

                                                                                                                                                                                    Returns true if a particular event type has any listeners attached to it.

                                                                                                                                                                                  method listens

                                                                                                                                                                                  listens: (type: string) => boolean;
                                                                                                                                                                                  • Returns true if a particular event type has any listeners attached to it.

                                                                                                                                                                                  method off

                                                                                                                                                                                  off: {
                                                                                                                                                                                  (type: string, fn?: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                  fn?: LayersControlEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                  fn?: LayerEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                  | 'load'
                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                  | 'move'
                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                  | 'add'
                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                  | 'error'
                                                                                                                                                                                  | 'update'
                                                                                                                                                                                  | 'down'
                                                                                                                                                                                  | 'predrag',
                                                                                                                                                                                  fn?: LeafletEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'resize', fn?: ResizeEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                  fn?: PopupEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                  fn?: TooltipEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'locationerror', fn?: ErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'locationfound', fn?: LocationEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'click'
                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                  fn?: LeafletMouseEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                  fn?: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'zoomanim', fn?: ZoomAnimEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'dragend', fn?: DragEndEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload',
                                                                                                                                                                                  fn?: TileEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'tileerror', fn?: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                  (): this;
                                                                                                                                                                                  };
                                                                                                                                                                                  • Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to on, you must pass the same context to off in order to remove the listener.

                                                                                                                                                                                  • Removes a set of type/listener pairs.

                                                                                                                                                                                  • Removes all listeners to all events on the object.

                                                                                                                                                                                  method on

                                                                                                                                                                                  on: {
                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                  fn: LayersControlEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                  fn: LayerEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                  | 'load'
                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                  | 'move'
                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                  | 'add'
                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                  | 'error'
                                                                                                                                                                                  | 'update'
                                                                                                                                                                                  | 'down'
                                                                                                                                                                                  | 'predrag',
                                                                                                                                                                                  fn: LeafletEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'resize', fn: ResizeEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                  fn: PopupEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                  fn: TooltipEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'locationerror', fn: ErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'locationfound', fn: LocationEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'click'
                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                  fn: LeafletMouseEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                  fn: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'zoomanim', fn: ZoomAnimEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'dragend', fn: DragEndEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload',
                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                  };
                                                                                                                                                                                  • Adds a listener function (fn) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. 'click dblclick').

                                                                                                                                                                                  • Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove}

                                                                                                                                                                                  method once

                                                                                                                                                                                  once: {
                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                  fn: LayersControlEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                  fn: LayerEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                  | 'load'
                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                  | 'move'
                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                  | 'add'
                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                  | 'error'
                                                                                                                                                                                  | 'update'
                                                                                                                                                                                  | 'down'
                                                                                                                                                                                  | 'predrag',
                                                                                                                                                                                  fn: LeafletEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'resize', fn: ResizeEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                  fn: PopupEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                  fn: TooltipEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'locationerror', fn: ErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'locationfound', fn: LocationEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'click'
                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                  fn: LeafletMouseEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                  fn: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'zoomanim', fn: ZoomAnimEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'dragend', fn: DragEndEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload',
                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'tileerror', fn: TileEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                  };
                                                                                                                                                                                  • Behaves as on(...), except the listener will only get fired once and then removed.

                                                                                                                                                                                  method removeEventListener

                                                                                                                                                                                  removeEventListener: {
                                                                                                                                                                                  (type: string, fn?: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                  fn?: LayersControlEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                  fn?: LayerEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                  | 'load'
                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                  | 'move'
                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                  | 'add'
                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                  | 'error'
                                                                                                                                                                                  | 'update'
                                                                                                                                                                                  | 'down'
                                                                                                                                                                                  | 'predrag',
                                                                                                                                                                                  fn?: LeafletEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'resize', fn?: ResizeEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                  fn?: PopupEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                  fn?: TooltipEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'locationerror', fn?: ErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'locationfound', fn?: LocationEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type:
                                                                                                                                                                                  | 'click'
                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                  fn?: LeafletMouseEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                  fn?: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'zoomanim', fn?: ZoomAnimEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (type: 'dragend', fn?: DragEndEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload',
                                                                                                                                                                                  fn?: TileEventHandlerFn,
                                                                                                                                                                                  context?: any
                                                                                                                                                                                  ): this;
                                                                                                                                                                                  (type: 'tileerror', fn?: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                  };
                                                                                                                                                                                  • Alias for off(...)

                                                                                                                                                                                    Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to on, you must pass the same context to off in order to remove the listener.

                                                                                                                                                                                  • Alias for off(...)

                                                                                                                                                                                    Removes a set of type/listener pairs.

                                                                                                                                                                                  method removeEventParent

                                                                                                                                                                                  removeEventParent: (obj: Evented) => this;
                                                                                                                                                                                  • Removes an event parent, so it will stop receiving propagated events

                                                                                                                                                                                  class FeatureGroup

                                                                                                                                                                                  class FeatureGroup<P = any> extends LayerGroup<P> {}
                                                                                                                                                                                  • Extended LayerGroup that also has mouse events (propagated from members of the group) and a shared bindPopup method.

                                                                                                                                                                                  method bringToBack

                                                                                                                                                                                  bringToBack: () => this;
                                                                                                                                                                                  • Brings the layer group to the top [sic] of all other layers

                                                                                                                                                                                  method bringToFront

                                                                                                                                                                                  bringToFront: () => this;
                                                                                                                                                                                  • Brings the layer group to the top of all other layers

                                                                                                                                                                                  method getBounds

                                                                                                                                                                                  getBounds: () => LatLngBounds;
                                                                                                                                                                                  • Returns the LatLngBounds of the Feature Group (created from bounds and coordinates of its children).

                                                                                                                                                                                  method setStyle

                                                                                                                                                                                  setStyle: (style: PathOptions) => this;
                                                                                                                                                                                  • Sets the given path options to each layer of the group that has a setStyle method.

                                                                                                                                                                                  class GeoJSON

                                                                                                                                                                                  class GeoJSON<P = any> extends FeatureGroup<P> {}
                                                                                                                                                                                  • Represents a GeoJSON object or an array of GeoJSON objects. Allows you to parse GeoJSON data and display it on the map. Extends FeatureGroup.

                                                                                                                                                                                  constructor

                                                                                                                                                                                  constructor(geojson?: any, options?: GeoJSONOptions<P>);

                                                                                                                                                                                    property options

                                                                                                                                                                                    options: GeoJSONOptions<P>;

                                                                                                                                                                                      method addData

                                                                                                                                                                                      addData: (data: any) => this;
                                                                                                                                                                                      • Adds a GeoJSON object to the layer.

                                                                                                                                                                                      method asFeature

                                                                                                                                                                                      static asFeature: <P = any>(
                                                                                                                                                                                      geojson: geojson.Feature<geojson.GeometryObject, P> | geojson.GeometryObject
                                                                                                                                                                                      ) => any;
                                                                                                                                                                                      • Normalize GeoJSON geometries/features into GeoJSON features.

                                                                                                                                                                                      method coordsToLatLng

                                                                                                                                                                                      static coordsToLatLng: (
                                                                                                                                                                                      coords: [number, number] | [number, number, number]
                                                                                                                                                                                      ) => LatLng;
                                                                                                                                                                                      • Creates a LatLng object from an array of 2 numbers (longitude, latitude) or 3 numbers (longitude, latitude, altitude) used in GeoJSON for points.

                                                                                                                                                                                      method coordsToLatLngs

                                                                                                                                                                                      static coordsToLatLngs: (
                                                                                                                                                                                      coords: any[],
                                                                                                                                                                                      levelsDeep?: number,
                                                                                                                                                                                      coordsToLatLng?: (
                                                                                                                                                                                      coords: [number, number] | [number, number, number]
                                                                                                                                                                                      ) => LatLng
                                                                                                                                                                                      ) => any[];
                                                                                                                                                                                      • Creates a multidimensional array of LatLngs from a GeoJSON coordinates array. levelsDeep specifies the nesting level (0 is for an array of points, 1 for an array of arrays of points, etc., 0 by default). Can use a custom coordsToLatLng function.

                                                                                                                                                                                      method geometryToLayer

                                                                                                                                                                                      static geometryToLayer: <P = any>(
                                                                                                                                                                                      featureData: any,
                                                                                                                                                                                      options?: GeoJSONOptions<P>
                                                                                                                                                                                      ) => Layer;
                                                                                                                                                                                      • Creates a Layer from a given GeoJSON feature. Can use a custom pointToLayer and/or coordsToLatLng functions if provided as options.

                                                                                                                                                                                      method latLngsToCoords

                                                                                                                                                                                      static latLngsToCoords: (
                                                                                                                                                                                      latlngs: any[],
                                                                                                                                                                                      levelsDeep?: number,
                                                                                                                                                                                      closed?: boolean
                                                                                                                                                                                      ) => any[];
                                                                                                                                                                                      • Reverse of coordsToLatLngs closed determines whether the first point should be appended to the end of the array to close the feature, only used when levelsDeep is 0. False by default.

                                                                                                                                                                                      method latLngToCoords

                                                                                                                                                                                      static latLngToCoords: (
                                                                                                                                                                                      latlng: LatLng
                                                                                                                                                                                      ) => [number, number] | [number, number, number];
                                                                                                                                                                                      • Reverse of coordsToLatLng

                                                                                                                                                                                      method resetStyle

                                                                                                                                                                                      resetStyle: (layer?: Layer) => this;
                                                                                                                                                                                      • Resets the given vector layer's style to the original GeoJSON style, useful for resetting style after hover events.

                                                                                                                                                                                      method setStyle

                                                                                                                                                                                      setStyle: (style: PathOptions | StyleFunction<P>) => this;
                                                                                                                                                                                      • Same as FeatureGroup's setStyle method, but style-functions are also allowed here to set the style according to the feature.

                                                                                                                                                                                      class GridLayer

                                                                                                                                                                                      class GridLayer extends Layer {}

                                                                                                                                                                                        constructor

                                                                                                                                                                                        constructor(options?: GridLayerOptions);

                                                                                                                                                                                          method bringToBack

                                                                                                                                                                                          bringToBack: () => this;

                                                                                                                                                                                            method bringToFront

                                                                                                                                                                                            bringToFront: () => this;

                                                                                                                                                                                              method createTile

                                                                                                                                                                                              protected createTile: (coords: Coords, done: DoneCallback) => HTMLElement;

                                                                                                                                                                                                method getContainer

                                                                                                                                                                                                getContainer: () => HTMLElement | null;

                                                                                                                                                                                                  method getTileSize

                                                                                                                                                                                                  getTileSize: () => Point;

                                                                                                                                                                                                    method isLoading

                                                                                                                                                                                                    isLoading: () => boolean;

                                                                                                                                                                                                      method redraw

                                                                                                                                                                                                      redraw: () => this;

                                                                                                                                                                                                        method setOpacity

                                                                                                                                                                                                        setOpacity: (opacity: number) => this;

                                                                                                                                                                                                          method setZIndex

                                                                                                                                                                                                          setZIndex: (zIndex: number) => this;

                                                                                                                                                                                                            class Handler

                                                                                                                                                                                                            class Handler extends Class {}

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(map: Map);

                                                                                                                                                                                                                method addHooks

                                                                                                                                                                                                                addHooks: () => void;

                                                                                                                                                                                                                  method disable

                                                                                                                                                                                                                  disable: () => this;

                                                                                                                                                                                                                    method enable

                                                                                                                                                                                                                    enable: () => this;

                                                                                                                                                                                                                      method enabled

                                                                                                                                                                                                                      enabled: () => boolean;

                                                                                                                                                                                                                        method removeHooks

                                                                                                                                                                                                                        removeHooks: () => void;

                                                                                                                                                                                                                          class Icon

                                                                                                                                                                                                                          class Icon<T extends BaseIconOptions = IconOptions> extends Layer {}

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor(options: BaseIconOptions);

                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                              options: BaseIconOptions;

                                                                                                                                                                                                                                method createIcon

                                                                                                                                                                                                                                createIcon: (oldIcon?: HTMLElement) => HTMLElement;

                                                                                                                                                                                                                                  method createShadow

                                                                                                                                                                                                                                  createShadow: (oldIcon?: HTMLElement) => HTMLElement;

                                                                                                                                                                                                                                    class ImageOverlay

                                                                                                                                                                                                                                    class ImageOverlay extends Layer {}

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                      imageUrl: string,
                                                                                                                                                                                                                                      bounds: LatLngBoundsExpression,
                                                                                                                                                                                                                                      options?: ImageOverlayOptions
                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                        options: ImageOverlayOptions;

                                                                                                                                                                                                                                          method bringToBack

                                                                                                                                                                                                                                          bringToBack: () => this;

                                                                                                                                                                                                                                            method bringToFront

                                                                                                                                                                                                                                            bringToFront: () => this;

                                                                                                                                                                                                                                              method getBounds

                                                                                                                                                                                                                                              getBounds: () => LatLngBounds;
                                                                                                                                                                                                                                              • Get the bounds that this ImageOverlay covers

                                                                                                                                                                                                                                              method getElement

                                                                                                                                                                                                                                              getElement: () => HTMLImageElement | undefined;
                                                                                                                                                                                                                                              • Get the img element that represents the ImageOverlay on the map

                                                                                                                                                                                                                                              method setBounds

                                                                                                                                                                                                                                              setBounds: (bounds: LatLngBounds) => this;
                                                                                                                                                                                                                                              • Update the bounds that this ImageOverlay covers

                                                                                                                                                                                                                                              method setOpacity

                                                                                                                                                                                                                                              setOpacity: (opacity: number) => this;

                                                                                                                                                                                                                                                method setUrl

                                                                                                                                                                                                                                                setUrl: (url: string) => this;

                                                                                                                                                                                                                                                  method setZIndex

                                                                                                                                                                                                                                                  setZIndex: (value: number) => this;
                                                                                                                                                                                                                                                  • Changes the zIndex of the image overlay

                                                                                                                                                                                                                                                  class LatLng

                                                                                                                                                                                                                                                  class LatLng {}

                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                    constructor(latitude: number, longitude: number, altitude?: number);

                                                                                                                                                                                                                                                      property alt

                                                                                                                                                                                                                                                      alt?: number;

                                                                                                                                                                                                                                                        property lat

                                                                                                                                                                                                                                                        lat: number;

                                                                                                                                                                                                                                                          property lng

                                                                                                                                                                                                                                                          lng: number;

                                                                                                                                                                                                                                                            method clone

                                                                                                                                                                                                                                                            clone: () => LatLng;

                                                                                                                                                                                                                                                              method distanceTo

                                                                                                                                                                                                                                                              distanceTo: (otherLatLng: LatLngExpression) => number;

                                                                                                                                                                                                                                                                method equals

                                                                                                                                                                                                                                                                equals: (otherLatLng: LatLngExpression, maxMargin?: number) => boolean;

                                                                                                                                                                                                                                                                  method toBounds

                                                                                                                                                                                                                                                                  toBounds: (sizeInMeters: number) => LatLngBounds;

                                                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                                                    toString: () => string;

                                                                                                                                                                                                                                                                      method wrap

                                                                                                                                                                                                                                                                      wrap: () => LatLng;

                                                                                                                                                                                                                                                                        class LatLngBounds

                                                                                                                                                                                                                                                                        class LatLngBounds {}

                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                          constructor(southWest: LatLngExpression, northEast: LatLngExpression);

                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                            constructor(latlngs: LatLngBoundsLiteral);

                                                                                                                                                                                                                                                                              method contains

                                                                                                                                                                                                                                                                              contains: (
                                                                                                                                                                                                                                                                              otherBoundsOrLatLng: LatLngBoundsExpression | LatLngExpression
                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                method equals

                                                                                                                                                                                                                                                                                equals: (otherBounds: LatLngBoundsExpression) => boolean;

                                                                                                                                                                                                                                                                                  method extend

                                                                                                                                                                                                                                                                                  extend: (latlngOrBounds: LatLngExpression | LatLngBoundsExpression) => this;

                                                                                                                                                                                                                                                                                    method getCenter

                                                                                                                                                                                                                                                                                    getCenter: () => LatLng;

                                                                                                                                                                                                                                                                                      method getEast

                                                                                                                                                                                                                                                                                      getEast: () => number;

                                                                                                                                                                                                                                                                                        method getNorth

                                                                                                                                                                                                                                                                                        getNorth: () => number;

                                                                                                                                                                                                                                                                                          method getNorthEast

                                                                                                                                                                                                                                                                                          getNorthEast: () => LatLng;

                                                                                                                                                                                                                                                                                            method getNorthWest

                                                                                                                                                                                                                                                                                            getNorthWest: () => LatLng;

                                                                                                                                                                                                                                                                                              method getSouth

                                                                                                                                                                                                                                                                                              getSouth: () => number;

                                                                                                                                                                                                                                                                                                method getSouthEast

                                                                                                                                                                                                                                                                                                getSouthEast: () => LatLng;

                                                                                                                                                                                                                                                                                                  method getSouthWest

                                                                                                                                                                                                                                                                                                  getSouthWest: () => LatLng;

                                                                                                                                                                                                                                                                                                    method getWest

                                                                                                                                                                                                                                                                                                    getWest: () => number;

                                                                                                                                                                                                                                                                                                      method intersects

                                                                                                                                                                                                                                                                                                      intersects: (otherBounds: LatLngBoundsExpression) => boolean;

                                                                                                                                                                                                                                                                                                        method isValid

                                                                                                                                                                                                                                                                                                        isValid: () => boolean;

                                                                                                                                                                                                                                                                                                          method overlaps

                                                                                                                                                                                                                                                                                                          overlaps: (otherBounds: LatLngBoundsExpression) => boolean;

                                                                                                                                                                                                                                                                                                            method pad

                                                                                                                                                                                                                                                                                                            pad: (bufferRatio: number) => LatLngBounds;

                                                                                                                                                                                                                                                                                                              method toBBoxString

                                                                                                                                                                                                                                                                                                              toBBoxString: () => string;

                                                                                                                                                                                                                                                                                                                class Layer

                                                                                                                                                                                                                                                                                                                class Layer extends Evented {}

                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                  constructor(options?: LayerOptions);

                                                                                                                                                                                                                                                                                                                    method addTo

                                                                                                                                                                                                                                                                                                                    addTo: (map: Map | LayerGroup) => this;

                                                                                                                                                                                                                                                                                                                      method beforeAdd

                                                                                                                                                                                                                                                                                                                      beforeAdd: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                        method bindPopup

                                                                                                                                                                                                                                                                                                                        bindPopup: (
                                                                                                                                                                                                                                                                                                                        content: Popup | ((layer: Layer) => Content) | Content,
                                                                                                                                                                                                                                                                                                                        options?: PopupOptions
                                                                                                                                                                                                                                                                                                                        ) => this;

                                                                                                                                                                                                                                                                                                                          method bindTooltip

                                                                                                                                                                                                                                                                                                                          bindTooltip: (
                                                                                                                                                                                                                                                                                                                          content: Tooltip | Content | ((layer: Layer) => Content),
                                                                                                                                                                                                                                                                                                                          options?: TooltipOptions
                                                                                                                                                                                                                                                                                                                          ) => this;

                                                                                                                                                                                                                                                                                                                            method closePopup

                                                                                                                                                                                                                                                                                                                            closePopup: () => this;

                                                                                                                                                                                                                                                                                                                              method closeTooltip

                                                                                                                                                                                                                                                                                                                              closeTooltip: () => this;

                                                                                                                                                                                                                                                                                                                                method getAttribution

                                                                                                                                                                                                                                                                                                                                getAttribution: () => string | null;

                                                                                                                                                                                                                                                                                                                                  method getEvents

                                                                                                                                                                                                                                                                                                                                  getEvents: () => { [name: string]: LeafletEventHandlerFn };

                                                                                                                                                                                                                                                                                                                                    method getPane

                                                                                                                                                                                                                                                                                                                                    getPane: (name?: string) => HTMLElement | undefined;

                                                                                                                                                                                                                                                                                                                                      method getPopup

                                                                                                                                                                                                                                                                                                                                      getPopup: () => Popup | undefined;

                                                                                                                                                                                                                                                                                                                                        method getTooltip

                                                                                                                                                                                                                                                                                                                                        getTooltip: () => Tooltip | undefined;

                                                                                                                                                                                                                                                                                                                                          method isPopupOpen

                                                                                                                                                                                                                                                                                                                                          isPopupOpen: () => boolean;

                                                                                                                                                                                                                                                                                                                                            method isTooltipOpen

                                                                                                                                                                                                                                                                                                                                            isTooltipOpen: () => boolean;

                                                                                                                                                                                                                                                                                                                                              method onAdd

                                                                                                                                                                                                                                                                                                                                              onAdd: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                                                method onRemove

                                                                                                                                                                                                                                                                                                                                                onRemove: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                                                  method openPopup

                                                                                                                                                                                                                                                                                                                                                  openPopup: (latlng?: LatLngExpression) => this;

                                                                                                                                                                                                                                                                                                                                                    method openTooltip

                                                                                                                                                                                                                                                                                                                                                    openTooltip: (latlng?: LatLngExpression) => this;

                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                      remove: () => this;

                                                                                                                                                                                                                                                                                                                                                        method removeFrom

                                                                                                                                                                                                                                                                                                                                                        removeFrom: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                                                          method setPopupContent

                                                                                                                                                                                                                                                                                                                                                          setPopupContent: (content: Content | Popup) => this;

                                                                                                                                                                                                                                                                                                                                                            method setTooltipContent

                                                                                                                                                                                                                                                                                                                                                            setTooltipContent: (content: Content | Tooltip) => this;

                                                                                                                                                                                                                                                                                                                                                              method togglePopup

                                                                                                                                                                                                                                                                                                                                                              togglePopup: () => this;

                                                                                                                                                                                                                                                                                                                                                                method toggleTooltip

                                                                                                                                                                                                                                                                                                                                                                toggleTooltip: () => this;

                                                                                                                                                                                                                                                                                                                                                                  method unbindPopup

                                                                                                                                                                                                                                                                                                                                                                  unbindPopup: () => this;

                                                                                                                                                                                                                                                                                                                                                                    method unbindTooltip

                                                                                                                                                                                                                                                                                                                                                                    unbindTooltip: () => this;

                                                                                                                                                                                                                                                                                                                                                                      class LayerGroup

                                                                                                                                                                                                                                                                                                                                                                      class LayerGroup<P = any> extends Layer {}
                                                                                                                                                                                                                                                                                                                                                                      • Used to group several layers and handle them as one. If you add it to the map, any layers added or removed from the group will be added/removed on the map as well. Extends Layer.

                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                      constructor(layers?: Layer[], options?: LayerOptions);

                                                                                                                                                                                                                                                                                                                                                                        property feature

                                                                                                                                                                                                                                                                                                                                                                        feature?: any;

                                                                                                                                                                                                                                                                                                                                                                          method addLayer

                                                                                                                                                                                                                                                                                                                                                                          addLayer: (layer: Layer) => this;
                                                                                                                                                                                                                                                                                                                                                                          • Adds the given layer to the group.

                                                                                                                                                                                                                                                                                                                                                                          method clearLayers

                                                                                                                                                                                                                                                                                                                                                                          clearLayers: () => this;
                                                                                                                                                                                                                                                                                                                                                                          • Removes all the layers from the group.

                                                                                                                                                                                                                                                                                                                                                                          method eachLayer

                                                                                                                                                                                                                                                                                                                                                                          eachLayer: (fn: (layer: Layer) => void, context?: any) => this;
                                                                                                                                                                                                                                                                                                                                                                          • Iterates over the layers of the group, optionally specifying context of the iterator function.

                                                                                                                                                                                                                                                                                                                                                                          method getLayer

                                                                                                                                                                                                                                                                                                                                                                          getLayer: (id: number) => Layer | undefined;
                                                                                                                                                                                                                                                                                                                                                                          • Returns the layer with the given internal ID.

                                                                                                                                                                                                                                                                                                                                                                          method getLayerId

                                                                                                                                                                                                                                                                                                                                                                          getLayerId: (layer: Layer) => number;
                                                                                                                                                                                                                                                                                                                                                                          • Returns the internal ID for a layer

                                                                                                                                                                                                                                                                                                                                                                          method getLayers

                                                                                                                                                                                                                                                                                                                                                                          getLayers: () => Layer[];
                                                                                                                                                                                                                                                                                                                                                                          • Returns an array of all the layers added to the group.

                                                                                                                                                                                                                                                                                                                                                                          method hasLayer

                                                                                                                                                                                                                                                                                                                                                                          hasLayer: (layer: Layer) => boolean;
                                                                                                                                                                                                                                                                                                                                                                          • Returns true if the given layer is currently added to the group.

                                                                                                                                                                                                                                                                                                                                                                          method invoke

                                                                                                                                                                                                                                                                                                                                                                          invoke: (methodName: string, ...params: any[]) => this;
                                                                                                                                                                                                                                                                                                                                                                          • Calls methodName on every layer contained in this group, passing any additional parameters. Has no effect if the layers contained do not implement methodName.

                                                                                                                                                                                                                                                                                                                                                                          method removeLayer

                                                                                                                                                                                                                                                                                                                                                                          removeLayer: (layer: number | Layer) => this;
                                                                                                                                                                                                                                                                                                                                                                          • Removes the layer with the given internal ID or the given layer from the group.

                                                                                                                                                                                                                                                                                                                                                                          method setZIndex

                                                                                                                                                                                                                                                                                                                                                                          setZIndex: (zIndex: number) => this;
                                                                                                                                                                                                                                                                                                                                                                          • Calls setZIndex on every layer contained in this group, passing the z-index.

                                                                                                                                                                                                                                                                                                                                                                          method toGeoJSON

                                                                                                                                                                                                                                                                                                                                                                          toGeoJSON: (
                                                                                                                                                                                                                                                                                                                                                                          precision?: number
                                                                                                                                                                                                                                                                                                                                                                          ) =>
                                                                                                                                                                                                                                                                                                                                                                          | geojson.FeatureCollection<geojson.GeometryObject, P>
                                                                                                                                                                                                                                                                                                                                                                          | geojson.Feature<geojson.MultiPoint, P>
                                                                                                                                                                                                                                                                                                                                                                          | geojson.GeometryCollection;
                                                                                                                                                                                                                                                                                                                                                                          • Returns a GeoJSON representation of the layer group (as a GeoJSON GeometryCollection, GeoJSONFeatureCollection or Multipoint).

                                                                                                                                                                                                                                                                                                                                                                          class Map

                                                                                                                                                                                                                                                                                                                                                                          class Map extends Evented {}

                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                            constructor(element: string | HTMLElement, options?: MapOptions);

                                                                                                                                                                                                                                                                                                                                                                              property attributionControl

                                                                                                                                                                                                                                                                                                                                                                              attributionControl: Control.Attribution;

                                                                                                                                                                                                                                                                                                                                                                                property boxZoom

                                                                                                                                                                                                                                                                                                                                                                                boxZoom: Handler;

                                                                                                                                                                                                                                                                                                                                                                                  property doubleClickZoom

                                                                                                                                                                                                                                                                                                                                                                                  doubleClickZoom: Handler;

                                                                                                                                                                                                                                                                                                                                                                                    property dragging

                                                                                                                                                                                                                                                                                                                                                                                    dragging: Handler;

                                                                                                                                                                                                                                                                                                                                                                                      property keyboard

                                                                                                                                                                                                                                                                                                                                                                                      keyboard: Handler;

                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                        options: MapOptions;

                                                                                                                                                                                                                                                                                                                                                                                          property scrollWheelZoom

                                                                                                                                                                                                                                                                                                                                                                                          scrollWheelZoom: Handler;

                                                                                                                                                                                                                                                                                                                                                                                            property tap

                                                                                                                                                                                                                                                                                                                                                                                            tap?: Handler;

                                                                                                                                                                                                                                                                                                                                                                                              property touchZoom

                                                                                                                                                                                                                                                                                                                                                                                              touchZoom: Handler;

                                                                                                                                                                                                                                                                                                                                                                                                property zoomControl

                                                                                                                                                                                                                                                                                                                                                                                                zoomControl: Control.Zoom;

                                                                                                                                                                                                                                                                                                                                                                                                  method addControl

                                                                                                                                                                                                                                                                                                                                                                                                  addControl: (control: Control) => this;

                                                                                                                                                                                                                                                                                                                                                                                                    method addHandler

                                                                                                                                                                                                                                                                                                                                                                                                    addHandler: (name: string, HandlerClass: typeof Handler) => this;

                                                                                                                                                                                                                                                                                                                                                                                                      method addLayer

                                                                                                                                                                                                                                                                                                                                                                                                      addLayer: (layer: Layer) => this;

                                                                                                                                                                                                                                                                                                                                                                                                        method closePopup

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

                                                                                                                                                                                                                                                                                                                                                                                                          method closeTooltip

                                                                                                                                                                                                                                                                                                                                                                                                          closeTooltip: (tooltip?: Tooltip) => this;

                                                                                                                                                                                                                                                                                                                                                                                                            method containerPointToLatLng

                                                                                                                                                                                                                                                                                                                                                                                                            containerPointToLatLng: (point: PointExpression) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                              method containerPointToLayerPoint

                                                                                                                                                                                                                                                                                                                                                                                                              containerPointToLayerPoint: (point: PointExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                method createPane

                                                                                                                                                                                                                                                                                                                                                                                                                createPane: (name: string, container?: HTMLElement) => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                  method distance

                                                                                                                                                                                                                                                                                                                                                                                                                  distance: (latlng1: LatLngExpression, latlng2: LatLngExpression) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                    method eachLayer

                                                                                                                                                                                                                                                                                                                                                                                                                    eachLayer: (fn: (layer: Layer) => void, context?: any) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                      method fitBounds

                                                                                                                                                                                                                                                                                                                                                                                                                      fitBounds: (bounds: LatLngBoundsExpression, options?: FitBoundsOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                        method fitWorld

                                                                                                                                                                                                                                                                                                                                                                                                                        fitWorld: (options?: FitBoundsOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                          method flyTo

                                                                                                                                                                                                                                                                                                                                                                                                                          flyTo: (
                                                                                                                                                                                                                                                                                                                                                                                                                          latlng: LatLngExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                          zoom?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                          options?: ZoomPanOptions
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                            method flyToBounds

                                                                                                                                                                                                                                                                                                                                                                                                                            flyToBounds: (
                                                                                                                                                                                                                                                                                                                                                                                                                            bounds: LatLngBoundsExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                            options?: FitBoundsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                              method getBounds

                                                                                                                                                                                                                                                                                                                                                                                                                              getBounds: () => LatLngBounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                method getBoundsZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                getBoundsZoom: (
                                                                                                                                                                                                                                                                                                                                                                                                                                bounds: LatLngBoundsExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                                inside?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                padding?: Point
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getCenter

                                                                                                                                                                                                                                                                                                                                                                                                                                  getCenter: () => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method getContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                    getContainer: () => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMaxZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                      getMaxZoom: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getMinZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                        getMinZoom: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPane

                                                                                                                                                                                                                                                                                                                                                                                                                                          getPane: (pane: string | HTMLElement) => HTMLElement | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Name of the pane or the pane as HTML-Element

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPanes

                                                                                                                                                                                                                                                                                                                                                                                                                                          getPanes: () => { [name: string]: HTMLElement } & DefaultMapPanes;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getPixelBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                            getPixelBounds: () => Bounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getPixelOrigin

                                                                                                                                                                                                                                                                                                                                                                                                                                              getPixelOrigin: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method getPixelWorldBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                getPixelWorldBounds: (zoom?: number) => Bounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getRenderer

                                                                                                                                                                                                                                                                                                                                                                                                                                                  getRenderer: (layer: Path) => Renderer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getScaleZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                    getScaleZoom: (scale: number, fromZoom?: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                      getSize: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                        getZoom: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getZoomScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                          getZoomScale: (toZoom: number, fromZoom?: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method hasLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                            hasLayer: (layer: Layer) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method invalidateSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                              invalidateSize: (options?: boolean | InvalidateSizeOptions) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Boolean for animate or advanced ZoomPanOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method latLngToContainerPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                              latLngToContainerPoint: (latlng: LatLngExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method latLngToLayerPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                latLngToLayerPoint: (latlng: LatLngExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method layerPointToContainerPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  layerPointToContainerPoint: (point: PointExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method layerPointToLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    layerPointToLatLng: (point: PointExpression) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method locate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      locate: (options?: LocateOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method mouseEventToContainerPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mouseEventToContainerPoint: (ev: MouseEvent) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method mouseEventToLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mouseEventToLatLng: (ev: MouseEvent) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method mouseEventToLayerPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mouseEventToLayerPoint: (ev: MouseEvent) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method openPopup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              openPopup: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (popup: Popup): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (content: Content, latlng: LatLngExpression, options?: PopupOptions): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method openTooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                openTooltip: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (tooltip: Tooltip): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (content: Content, latlng: LatLngExpression, options?: TooltipOptions): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method panBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  panBy: (offset: PointExpression, options?: PanOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method panInside

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    panInside: (latLng: LatLngExpression, options?: PanInsideOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method panInsideBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      panInsideBounds: (bounds: LatLngBoundsExpression, options?: PanOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method panTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        panTo: (latlng: LatLngExpression, options?: PanOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          project: (latlng: LatLngExpression, zoom?: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            remove: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method removeControl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeControl: (control: Control) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method removeLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeLayer: (layer: Layer) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setMaxBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setMaxBounds: (bounds: LatLngBoundsExpression) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setMaxZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setMaxZoom: (zoom: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setMinZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setMinZoom: (zoom: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setView: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        center: LatLngExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        zoom?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: ZoomPanOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setZoom: (zoom: number, options?: ZoomPanOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setZoomAround

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setZoomAround: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            position: Point | LatLngExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            zoom: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: ZoomOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stop: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method stopLocate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stopLocate: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method unproject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unproject: (point: PointExpression, zoom?: number) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method whenReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    whenReady: (fn: () => void, context?: any) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method wrapLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      wrapLatLng: (latlng: LatLngExpression) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method wrapLatLngBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wrapLatLngBounds: (bounds: LatLngBounds) => LatLngBounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method zoomIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          zoomIn: (delta?: number, options?: ZoomOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method zoomOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            zoomOut: (delta?: number, options?: ZoomOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Marker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Marker<P = any> extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(latlng: LatLngExpression, options?: MarkerOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dragging

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dragging?: Handler;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property feature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    feature?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: MarkerOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getElement: () => HTMLElement | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getIcon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getIcon: () => Icon | DivIcon;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getLatLng: () => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setIcon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setIcon: (icon: Icon | DivIcon) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setLatLng: (latlng: LatLngExpression) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setOpacity: (opacity: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setZIndexOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setZIndexOffset: (offset: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toGeoJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toGeoJSON: (precision?: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract class Path extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: PathOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method bringToBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bringToBack: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method bringToFront

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bringToFront: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getElement: () => Element | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method redraw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  redraw: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setStyle: (style: PathOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Point {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(x: number, y: number, round?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              add: (otherPoint: PointExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method ceil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ceil: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clone: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method contains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contains: (otherPoint: PointExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method distanceTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      distanceTo: (otherPoint: PointExpression) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method divideBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        divideBy: (num: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          equals: (otherPoint: PointExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method floor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            floor: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method multiplyBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              multiplyBy: (num: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method round

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                round: () => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method scaleBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scaleBy: (scale: PointExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method subtract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    subtract: (otherPoint: PointExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method unscaleBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        unscaleBy: (scale: PointExpression) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Polygon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Polygon<P = any> extends Polyline<geojson.Polygon | geojson.MultiPolygon, P> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            latlngs: LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: PolylineOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Polyline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Polyline<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              T extends geojson.GeometryObject = geojson.LineString | geojson.MultiLineString,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              P = any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > extends Path {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                latlngs: LatLngExpression[] | LatLngExpression[][],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: PolylineOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property feature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  feature?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: PolylineOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method addLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addLatLng: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      latlng: LatLngExpression | LatLngExpression[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      latlngs?: LatLng[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method closestLayerPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        closestLayerPoint: (p: Point) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getBounds: () => LatLngBounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getCenter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getCenter: () => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getLatLngs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getLatLngs: () => LatLng[] | LatLng[][] | LatLng[][][];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setLatLngs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setLatLngs: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  latlngs: LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toGeoJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toGeoJSON: (precision?: number) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Popup extends DivOverlay {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(options?: PopupOptions, source?: Layer);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: PopupOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method openOn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            openOn: (map: Map) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Rectangle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Rectangle<P = any> extends Polygon<P> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(latLngBounds: LatLngBoundsExpression, options?: PolylineOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setBounds: (latLngBounds: LatLngBoundsExpression) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Renderer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Renderer extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(options?: RendererOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: RendererOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class SVG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class SVG extends Renderer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SVGOverlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SVGOverlay extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              svgImage: string | SVGElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bounds: LatLngBoundsExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: ImageOverlayOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: ImageOverlayOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method bringToBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bringToBack: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method bringToFront

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bringToFront: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBounds: () => LatLngBounds;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Get the bounds that this SVGOverlay covers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getElement: () => SVGElement | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Get the img element that represents the SVGOverlay on the map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setBounds: (bounds: LatLngBounds) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Update the bounds that this SVGOverlay covers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setOpacity: (opacity: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setUrl: (url: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setZIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setZIndex: (value: number) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Changes the zIndex of the image overlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TileLayer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TileLayer extends GridLayer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(urlTemplate: string, options?: TileLayerOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: TileLayerOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getTileUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getTileUrl: (coords: L.Coords) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setUrl: (url: string, noRedraw?: boolean) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Tooltip extends DivOverlay {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(options?: TooltipOptions, source?: Layer);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: TooltipOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setOpacity: (val: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Transformation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Transformation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(a: number, b: number, c: number, d: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transform: (point: Point, scale?: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method untransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  untransform: (point: Point, scale?: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class VideoOverlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class VideoOverlay extends Layer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      video: string | string[] | HTMLVideoElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bounds: LatLngBoundsExpression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: VideoOverlayOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options: VideoOverlayOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method bringToBack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bringToBack: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method bringToFront

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bringToFront: () => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getBounds: () => LatLngBounds;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the bounds that this VideoOverlay covers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getElement: () => HTMLVideoElement | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the video element that represents the VideoOverlay on the map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setBounds: (bounds: LatLngBounds) => this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Update the bounds that this VideoOverlay covers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setOpacity: (opacity: number) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setUrl: (url: string) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BaseIconOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BaseIconOptions extends LayerOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    className?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property iconAnchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iconAnchor?: PointExpression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property iconRetinaUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        iconRetinaUrl?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property iconSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iconSize?: PointExpression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property iconUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            iconUrl?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property popupAnchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              popupAnchor?: PointExpression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property shadowAnchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                shadowAnchor?: PointExpression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property shadowRetinaUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shadowRetinaUrl?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property shadowSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shadowSize?: PointExpression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property shadowUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shadowUrl?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tooltipAnchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tooltipAnchor?: PointExpression | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CircleMarkerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CircleMarkerOptions extends PathOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property radius

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            radius?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ControlOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ControlOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                position?: ControlPosition | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Coords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Coords extends Point {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    z: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CRS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CRS {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        code?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property infinite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          infinite: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property wrapLat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            wrapLat?: [number, number] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property wrapLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              wrapLng?: [number, number] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                distance: (latlng1: LatLngExpression, latlng2: LatLngExpression) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getProjectedBounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getProjectedBounds: (zoom: number) => Bounds;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method latLngToPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    latLngToPoint: (latlng: LatLngExpression, zoom: number) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method pointToLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pointToLatLng: (point: PointExpression, zoom: number) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        project: (latlng: LatLng | LatLngLiteral) => Point;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scale: (zoom: number) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method unproject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unproject: (point: PointExpression) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method wrapLatLng

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              wrapLatLng: (latlng: LatLng | LatLngLiteral) => LatLng;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method zoom