@types/leaflet

  • Version 1.9.6
  • Published
  • 113 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 Mixin

      const Mixin: MixinType;

        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, G extends geojson.GeometryObject = geojson.GeometryObject>(
                      geojson?: geojson.GeoJsonObject | geojson.GeoJsonObject[],
                      options?: GeoJSONOptions<P, G>
                      ) => GeoJSON<P, G>;

                        function geoJSON

                        geoJSON: <P = any, G extends geojson.GeometryObject = geojson.GeometryObject>(
                        geojson?: geojson.GeoJsonObject | geojson.GeoJsonObject[],
                        options?: GeoJSONOptions<P, G>
                        ) => GeoJSON<P, G>;
                        • 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 noConflict

                                    noConflict: () => any;

                                      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 equals

                                                                      equals: (otherBounds: BoundsExpression) => boolean;

                                                                        method extend

                                                                        extend: {
                                                                        (point: PointExpression): this;
                                                                        (otherBounds: BoundsExpression): 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;

                                                                                            method pad

                                                                                            pad: (bufferRatio: number) => Bounds;

                                                                                              class Canvas

                                                                                              class Canvas extends Renderer {}

                                                                                                class Circle

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

                                                                                                  constructor

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

                                                                                                    constructor

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

                                                                                                      method getBounds

                                                                                                      getBounds: () => LatLngBounds;

                                                                                                        method getRadius

                                                                                                        getRadius: () => number;

                                                                                                          method setRadius

                                                                                                          setRadius: (radius: number) => this;

                                                                                                            method setStyle

                                                                                                            setStyle: (style: PathOptions) => this;

                                                                                                              method toGeoJSON

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

                                                                                                                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 setStyle

                                                                                                                                setStyle: (options: CircleMarkerOptions) => this;

                                                                                                                                  method toGeoJSON

                                                                                                                                  toGeoJSON: (precision?: number | false) => geojson.Feature<geojson.Point, P>;

                                                                                                                                    class Class

                                                                                                                                    class Class {}

                                                                                                                                      method addInitHook

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

                                                                                                                                        method callInitHooks

                                                                                                                                        static callInitHooks: () => void;

                                                                                                                                          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(latlng: LatLngExpression, options?: TooltipOptions);

                                                                                                                                                                              constructor

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

                                                                                                                                                                                property options

                                                                                                                                                                                options: DivOverlayOptions;

                                                                                                                                                                                  method bringToBack

                                                                                                                                                                                  bringToBack: () => this;

                                                                                                                                                                                    method bringToFront

                                                                                                                                                                                    bringToFront: () => this;

                                                                                                                                                                                      method close

                                                                                                                                                                                      close: () => this;

                                                                                                                                                                                        method getContent

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

                                                                                                                                                                                          method getElement

                                                                                                                                                                                          getElement: () => HTMLElement | undefined;

                                                                                                                                                                                            method getLatLng

                                                                                                                                                                                            getLatLng: () => LatLng | undefined;

                                                                                                                                                                                              method isOpen

                                                                                                                                                                                              isOpen: () => boolean;

                                                                                                                                                                                                method openOn

                                                                                                                                                                                                openOn: (map: Map) => this;

                                                                                                                                                                                                  method setContent

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

                                                                                                                                                                                                    method setLatLng

                                                                                                                                                                                                    setLatLng: (latlng: LatLngExpression) => this;

                                                                                                                                                                                                      method toggle

                                                                                                                                                                                                      toggle: (layer?: Layer) => 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,
                                                                                                                                                                                                          options?: DraggableOptions
                                                                                                                                                                                                          );

                                                                                                                                                                                                            method disable

                                                                                                                                                                                                            disable: () => void;

                                                                                                                                                                                                              method enable

                                                                                                                                                                                                              enable: () => void;

                                                                                                                                                                                                                method finishDrag

                                                                                                                                                                                                                finishDrag: () => void;

                                                                                                                                                                                                                  class Evented

                                                                                                                                                                                                                  abstract class Evented extends Class {}
                                                                                                                                                                                                                  • Base class of Leaflet classes supporting events

                                                                                                                                                                                                                  method addEventListener

                                                                                                                                                                                                                  addEventListener: {
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, 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:
                                                                                                                                                                                                                  | 'baselayerchange'
                                                                                                                                                                                                                  | 'overlayadd'
                                                                                                                                                                                                                  | 'overlayremove'
                                                                                                                                                                                                                  | 'layeradd'
                                                                                                                                                                                                                  | 'layerremove'
                                                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                                                  | 'load'
                                                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                                                  | 'move'
                                                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                                                  | 'add'
                                                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                                                  | 'error'
                                                                                                                                                                                                                  | 'update'
                                                                                                                                                                                                                  | 'down'
                                                                                                                                                                                                                  | 'predrag'
                                                                                                                                                                                                                  | 'resize'
                                                                                                                                                                                                                  | 'popupopen'
                                                                                                                                                                                                                  | 'tooltipopen'
                                                                                                                                                                                                                  | 'tooltipclose'
                                                                                                                                                                                                                  | 'locationerror'
                                                                                                                                                                                                                  | 'locationfound'
                                                                                                                                                                                                                  | 'click'
                                                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                                                  | 'preclick'
                                                                                                                                                                                                                  | 'keypress'
                                                                                                                                                                                                                  | 'keydown'
                                                                                                                                                                                                                  | 'keyup'
                                                                                                                                                                                                                  | 'zoomanim'
                                                                                                                                                                                                                  | 'dragend'
                                                                                                                                                                                                                  | 'tileunload'
                                                                                                                                                                                                                  | 'tileloadstart'
                                                                                                                                                                                                                  | 'tileload'
                                                                                                                                                                                                                  | 'tileabort'
                                                                                                                                                                                                                  | 'tileerror',
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                                                  fn: LayersControlEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                                                  fn: LayerEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'resize',
                                                                                                                                                                                                                  fn: ResizeEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                                                  fn: PopupEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                                                  fn: TooltipEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'locationerror',
                                                                                                                                                                                                                  fn: ErrorEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'locationfound',
                                                                                                                                                                                                                  fn: LocationEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type:
                                                                                                                                                                                                                  | 'click'
                                                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                                                  fn: LeafletMouseEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                                                  fn: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'zoomanim',
                                                                                                                                                                                                                  fn: ZoomAnimEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'dragend',
                                                                                                                                                                                                                  fn: DragEndEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'tileerror',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: string,
                                                                                                                                                                                                                  fn: LeafletEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  • Returns true if a particular event type has any listeners attached to it.

                                                                                                                                                                                                                  method off

                                                                                                                                                                                                                  off: {
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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' | 'tileabort',
                                                                                                                                                                                                                  fn?: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn?: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn?: LeafletEventHandlerFn, 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  • Behaves as on(...), except the listener will only get fired once and then removed.

                                                                                                                                                                                                                  method removeEventListener

                                                                                                                                                                                                                  removeEventListener: {
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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' | 'tileabort',
                                                                                                                                                                                                                  fn?: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn?: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn?: LeafletEventHandlerFn, 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 Events

                                                                                                                                                                                                                  class Events {}
                                                                                                                                                                                                                  • 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, 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:
                                                                                                                                                                                                                  | 'baselayerchange'
                                                                                                                                                                                                                  | 'overlayadd'
                                                                                                                                                                                                                  | 'overlayremove'
                                                                                                                                                                                                                  | 'layeradd'
                                                                                                                                                                                                                  | 'layerremove'
                                                                                                                                                                                                                  | 'zoomlevelschange'
                                                                                                                                                                                                                  | 'unload'
                                                                                                                                                                                                                  | 'viewreset'
                                                                                                                                                                                                                  | 'load'
                                                                                                                                                                                                                  | 'zoomstart'
                                                                                                                                                                                                                  | 'movestart'
                                                                                                                                                                                                                  | 'zoom'
                                                                                                                                                                                                                  | 'move'
                                                                                                                                                                                                                  | 'zoomend'
                                                                                                                                                                                                                  | 'moveend'
                                                                                                                                                                                                                  | 'autopanstart'
                                                                                                                                                                                                                  | 'dragstart'
                                                                                                                                                                                                                  | 'drag'
                                                                                                                                                                                                                  | 'add'
                                                                                                                                                                                                                  | 'remove'
                                                                                                                                                                                                                  | 'loading'
                                                                                                                                                                                                                  | 'error'
                                                                                                                                                                                                                  | 'update'
                                                                                                                                                                                                                  | 'down'
                                                                                                                                                                                                                  | 'predrag'
                                                                                                                                                                                                                  | 'resize'
                                                                                                                                                                                                                  | 'popupopen'
                                                                                                                                                                                                                  | 'tooltipopen'
                                                                                                                                                                                                                  | 'tooltipclose'
                                                                                                                                                                                                                  | 'locationerror'
                                                                                                                                                                                                                  | 'locationfound'
                                                                                                                                                                                                                  | 'click'
                                                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                                                  | 'preclick'
                                                                                                                                                                                                                  | 'keypress'
                                                                                                                                                                                                                  | 'keydown'
                                                                                                                                                                                                                  | 'keyup'
                                                                                                                                                                                                                  | 'zoomanim'
                                                                                                                                                                                                                  | 'dragend'
                                                                                                                                                                                                                  | 'tileunload'
                                                                                                                                                                                                                  | 'tileloadstart'
                                                                                                                                                                                                                  | 'tileload'
                                                                                                                                                                                                                  | 'tileabort'
                                                                                                                                                                                                                  | 'tileerror',
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'baselayerchange' | 'overlayadd' | 'overlayremove',
                                                                                                                                                                                                                  fn: LayersControlEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'layeradd' | 'layerremove',
                                                                                                                                                                                                                  fn: LayerEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'resize',
                                                                                                                                                                                                                  fn: ResizeEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'popupopen' | 'popupclose',
                                                                                                                                                                                                                  fn: PopupEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'tooltipopen' | 'tooltipclose',
                                                                                                                                                                                                                  fn: TooltipEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'locationerror',
                                                                                                                                                                                                                  fn: ErrorEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'locationfound',
                                                                                                                                                                                                                  fn: LocationEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type:
                                                                                                                                                                                                                  | 'click'
                                                                                                                                                                                                                  | 'dblclick'
                                                                                                                                                                                                                  | 'mousedown'
                                                                                                                                                                                                                  | 'mouseup'
                                                                                                                                                                                                                  | 'mouseover'
                                                                                                                                                                                                                  | 'mouseout'
                                                                                                                                                                                                                  | 'mousemove'
                                                                                                                                                                                                                  | 'contextmenu'
                                                                                                                                                                                                                  | 'preclick',
                                                                                                                                                                                                                  fn: LeafletMouseEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'keypress' | 'keydown' | 'keyup',
                                                                                                                                                                                                                  fn: LeafletKeyboardEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'zoomanim',
                                                                                                                                                                                                                  fn: ZoomAnimEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'dragend',
                                                                                                                                                                                                                  fn: DragEndEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'tileunload' | 'tileloadstart' | 'tileload' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'tileerror',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: string,
                                                                                                                                                                                                                  fn: LeafletEventHandlerFn,
                                                                                                                                                                                                                  context?: any,
                                                                                                                                                                                                                  propagate?: boolean
                                                                                                                                                                                                                  ): boolean;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  • Returns true if a particular event type has any listeners attached to it.

                                                                                                                                                                                                                  method off

                                                                                                                                                                                                                  off: {
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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' | 'tileabort',
                                                                                                                                                                                                                  fn?: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn?: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn?: LeafletEventHandlerFn, 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, 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: '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' | 'tileabort',
                                                                                                                                                                                                                  fn: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn: TileEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn: LeafletEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (eventMap: LeafletEventHandlerFnMap): this;
                                                                                                                                                                                                                  };
                                                                                                                                                                                                                  • Behaves as on(...), except the listener will only get fired once and then removed.

                                                                                                                                                                                                                  method removeEventListener

                                                                                                                                                                                                                  removeEventListener: {
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  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' | 'tileabort',
                                                                                                                                                                                                                  fn?: TileEventHandlerFn,
                                                                                                                                                                                                                  context?: any
                                                                                                                                                                                                                  ): this;
                                                                                                                                                                                                                  (type: 'tileerror', fn?: TileErrorEventHandlerFn, context?: any): this;
                                                                                                                                                                                                                  (type: string, fn?: LeafletEventHandlerFn, 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 addLayer

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

                                                                                                                                                                                                                  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 removeLayer

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

                                                                                                                                                                                                                  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,
                                                                                                                                                                                                                  G extends geojson.GeometryObject = geojson.GeometryObject
                                                                                                                                                                                                                  > 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?: geojson.GeoJsonObject, options?: GeoJSONOptions<P, G>);

                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                    options: GeoJSONOptions<P, G>;

                                                                                                                                                                                                                      method addData

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

                                                                                                                                                                                                                      method asFeature

                                                                                                                                                                                                                      static asFeature: <
                                                                                                                                                                                                                      P = any,
                                                                                                                                                                                                                      G extends geojson.GeometryObject = geojson.GeometryObject
                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                      geojson: geojson.Feature<G, P> | G
                                                                                                                                                                                                                      ) => geojson.Feature<G, P>;
                                                                                                                                                                                                                      • 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,
                                                                                                                                                                                                                      G extends geojson.GeometryObject = geojson.GeometryObject
                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                      featureData: geojson.Feature<G, P>,
                                                                                                                                                                                                                      options?: GeoJSONOptions<P, G>
                                                                                                                                                                                                                      ) => Layer;
                                                                                                                                                                                                                      • Creates a Layer from a given GeoJSON feature. Can use a custom pointToLayer and/or coordsToLatLng functions if provided as options.

                                                                                                                                                                                                                      method getFeature

                                                                                                                                                                                                                      static getFeature: <
                                                                                                                                                                                                                      P = any,
                                                                                                                                                                                                                      G extends geojson.GeometryObject = geojson.GeometryObject
                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                      layer: Layer,
                                                                                                                                                                                                                      newGeometry: geojson.Feature<G, P> | G
                                                                                                                                                                                                                      ) => geojson.Feature<G, P>;
                                                                                                                                                                                                                      • Convert layer into GeoJSON feature

                                                                                                                                                                                                                      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 getCenter

                                                                                                                                                                                                                                                                              getCenter: () => Point;
                                                                                                                                                                                                                                                                              • Get the center of the bounds 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;
                                                                                                                                                                                                                                                                              • Changes the opacity of the image element

                                                                                                                                                                                                                                                                              method setStyle

                                                                                                                                                                                                                                                                              setStyle: (styleOpts: ImageOverlayStyleOptions) => this;
                                                                                                                                                                                                                                                                              • Changes the style of the image element. As of 1.8, only the opacity is changed

                                                                                                                                                                                                                                                                              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, maxMargin?: number) => 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);

                                                                                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                                                                                  options: LayerOptions;

                                                                                                                                                                                                                                                                                                                                                    method addInteractiveTarget

                                                                                                                                                                                                                                                                                                                                                    addInteractiveTarget: (targetEl: HTMLElement) => this;

                                                                                                                                                                                                                                                                                                                                                      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 removeInteractiveTarget

                                                                                                                                                                                                                                                                                                                                                                                            removeInteractiveTarget: (targetEl: HTMLElement) => 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 | false
                                                                                                                                                                                                                                                                                                                                                                                                              ) =>
                                                                                                                                                                                                                                                                                                                                                                                                              | 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).

                                                                                                                                                                                                                                                                                                                                                                                                              method toMultiPoint

                                                                                                                                                                                                                                                                                                                                                                                                              toMultiPoint: (precision?: number) => geojson.Feature<geojson.MultiPoint, P>;

                                                                                                                                                                                                                                                                                                                                                                                                                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