@types/leaflet

  • Version 1.7.5
  • Published
  • 79.7 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 isValid

                                                                                isValid: () => 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