From b5eaa88e9effe4eebf076951217bdaf3be861721 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alejandro=20S=C3=A1nchez?= <sanchezajsa@gmail.com>
Date: Thu, 24 Aug 2017 17:18:50 -0600
Subject: [PATCH] Updated leaflet typings to match v1.2.x and to use newer
 typescript features

---
 .../esri-leaflet-geocoder-tests.ts            |    3 +-
 types/esri-leaflet-geocoder/index.d.ts        |   10 +-
 types/esri-leaflet/esri-leaflet-tests.ts      |   17 +-
 types/esri-leaflet/index.d.ts                 |   13 +-
 types/leaflet-areaselect/index.d.ts           |    4 +-
 .../leaflet-areaselect-tests.ts               |    5 +-
 types/leaflet-areaselect/tslint.json          |    4 +-
 types/leaflet-curve/index.d.ts                |    8 +-
 types/leaflet-curve/leaflet-curve-tests.ts    |   46 +-
 types/leaflet-curve/tslint.json               |    1 +
 types/leaflet-draw/index.d.ts                 |    5 +-
 types/leaflet-draw/leaflet-draw-tests.ts      |    9 +-
 types/leaflet-editable/index.d.ts             |   74 +-
 .../leaflet-editable-tests.ts                 |   15 +-
 types/leaflet-editable/tslint.json            |    1 +
 types/leaflet-fullscreen/index.d.ts           |    4 +-
 .../leaflet-fullscreen-tests.ts               |    2 +
 types/leaflet-fullscreen/tslint.json          |    4 +-
 types/leaflet-geocoder-mapzen/index.d.ts      |   34 +-
 .../leaflet-geocoder-mapzen-tests.ts          |   11 +-
 types/leaflet-geocoder-mapzen/tslint.json     |    1 +
 types/leaflet-imageoverlay-rotated/index.d.ts |    8 +-
 .../leaflet-imageoverlay-rotated-tests.ts     |    3 +
 types/leaflet-label/index.d.ts                |  130 +-
 types/leaflet-label/leaflet-label-tests.ts    |    5 +-
 types/leaflet-polylinedecorator/index.d.ts    |    5 +-
 .../leaflet-polylinedecorator-tests.ts        |    3 +
 types/leaflet-providers/index.d.ts            |    6 +-
 .../leaflet-providers-tests.ts                |    3 +
 types/leaflet.awesome-markers/index.d.ts      |   50 +-
 .../leaflet.awesome-markers-tests.ts          |    9 +-
 types/leaflet.awesome-markers/tslint.json     |    1 +
 types/leaflet.fullscreen/index.d.ts           |   33 +-
 .../leaflet.fullscreen-tests.ts               |    9 +-
 types/leaflet.fullscreen/tslint.json          |    1 +
 .../leaflet.gridlayer.googlemutant/index.d.ts |  140 +-
 .../leaflet.gridlayer.googlemutant-tests.ts   |    9 +-
 types/leaflet.locatecontrol/index.d.ts        |    5 +-
 .../leaflet.locatecontrol-tests.ts            |    3 +
 .../index.d.ts                                |   11 +-
 ...eaflet.markercluster.layersupport-tests.ts |    3 +-
 types/leaflet.markercluster/index.d.ts        |    9 +-
 .../leaflet.markercluster-tests.ts            |    3 +-
 types/leaflet.pm/index.d.ts                   |    5 +-
 types/leaflet.pm/leaflet.pm-tests.ts          |    3 +
 types/leaflet/index.d.ts                      | 2961 ++++++++---------
 types/leaflet/leaflet-tests.ts                |    6 +-
 types/proj4leaflet/index.d.ts                 |   19 +-
 types/proj4leaflet/proj4leaflet-tests.ts      |    6 +-
 types/react-leaflet/index.d.ts                |   98 +-
 types/react-leaflet/react-leaflet-tests.tsx   |   60 +-
 51 files changed, 1939 insertions(+), 1939 deletions(-)
 create mode 100644 types/leaflet-curve/tslint.json
 create mode 100644 types/leaflet-editable/tslint.json
 create mode 100644 types/leaflet-geocoder-mapzen/tslint.json
 create mode 100644 types/leaflet.awesome-markers/tslint.json
 create mode 100644 types/leaflet.fullscreen/tslint.json

diff --git a/types/esri-leaflet-geocoder/esri-leaflet-geocoder-tests.ts b/types/esri-leaflet-geocoder/esri-leaflet-geocoder-tests.ts
index a79e8f068f..09b6c94288 100644
--- a/types/esri-leaflet-geocoder/esri-leaflet-geocoder-tests.ts
+++ b/types/esri-leaflet-geocoder/esri-leaflet-geocoder-tests.ts
@@ -1,4 +1,5 @@
-import * as L from 'esri-leaflet-geocoder';
+import * as L from 'leaflet';
+import 'esri-leaflet-geocoder';
 
 const map = L.map('map').setView([45.5165, -122.6764], 12);
 const tiles = L.esri.basemapLayer("Streets").addTo(map);
diff --git a/types/esri-leaflet-geocoder/index.d.ts b/types/esri-leaflet-geocoder/index.d.ts
index 50c1ff779b..593f7cbb0b 100644
--- a/types/esri-leaflet-geocoder/index.d.ts
+++ b/types/esri-leaflet-geocoder/index.d.ts
@@ -4,13 +4,11 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.4
 
-import * as leaflet from 'leaflet';
-import * as esriLeaflet from 'esri-leaflet';
+import * as L from 'leaflet';
+import 'esri-leaflet';
 
-export = L;
-
-declare global {
-    namespace L.esri.Geocoding {
+declare module 'leaflet' {
+    namespace esri.Geocoding {
         type GeosearchConstructor = new (options?: GeosearchObject) => Geosearch;
         type Geosearch = GeosearchControl & Evented;
 
diff --git a/types/esri-leaflet/esri-leaflet-tests.ts b/types/esri-leaflet/esri-leaflet-tests.ts
index d0f1249232..89520101a3 100644
--- a/types/esri-leaflet/esri-leaflet-tests.ts
+++ b/types/esri-leaflet/esri-leaflet-tests.ts
@@ -4,14 +4,17 @@
 // tslint:disable:only-arrow-functions
 // tslint:disable:space-before-function-paren
 
-let latlng: L.LatLng = new L.LatLng(0, 0);
-let latlngbounds: L.LatLngBounds = new L.LatLngBounds(latlng, latlng);
-let map: L.Map = new L.Map('map');
+import * as L from 'leaflet';
+import 'esri-leaflet';
 
-let marker: L.Marker = new L.Marker(latlng);
-let polygon: L.Polygon = new L.Polygon([latlng, latlng]);
-let polyline: L.Polyline = new L.Polyline([latlng, latlng]);
-let geojson: L.GeoJSON = new L.GeoJSON();
+const latlng: L.LatLng = new L.LatLng(0, 0);
+const latlngbounds: L.LatLngBounds = new L.LatLngBounds(latlng, latlng);
+const map: L.Map = new L.Map('map');
+
+const marker: L.Marker = new L.Marker(latlng);
+const polygon: L.Polygon = new L.Polygon([latlng, latlng]);
+const polyline: L.Polyline = new L.Polyline([latlng, latlng]);
+const geojson: L.GeoJSON = new L.GeoJSON();
 
 let basemapLayer: L.esri.BasemapLayer;
 basemapLayer = L.esri.basemapLayer('Streets');
diff --git a/types/esri-leaflet/index.d.ts b/types/esri-leaflet/index.d.ts
index a79322983e..07cab832e0 100644
--- a/types/esri-leaflet/index.d.ts
+++ b/types/esri-leaflet/index.d.ts
@@ -2,10 +2,11 @@
 // Project: http://esri.github.io/esri-leaflet
 // Definitions by: strajuser <https://github.com/strajuser>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
     namespace esri {
         type CallbackHandler = (error: any, metadata: any) => void;
 
@@ -834,11 +835,7 @@ declare namespace L {
          * @returns {FeatureLayer}
          */
         function featureLayer(options: FeatureLayerOptions): FeatureLayer;
-    }
-}
 
-declare namespace L {
-    namespace esri {
         type FeatureCallbackHandler = (error?: any, featureCollection?: any, response?: any) => void;
         type ResponseCallbackHandler = (error?: any, response?: any) => void;
 
@@ -1621,7 +1618,3 @@ declare namespace L {
         function find(options: FindOptions | MapService): Find;
     }
 }
-
-declare module 'esri-leaflet' {
-    export = L.esri;
-}
diff --git a/types/leaflet-areaselect/index.d.ts b/types/leaflet-areaselect/index.d.ts
index 7c3fe5a476..50b0202f6a 100644
--- a/types/leaflet-areaselect/index.d.ts
+++ b/types/leaflet-areaselect/index.d.ts
@@ -3,9 +3,9 @@
 // Definitions by: André Wallat <https://github.com/awallat>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
   function areaSelect(box: AreaSelectOptions): AreaSelect;
 
   interface AreaSelectOptions {
diff --git a/types/leaflet-areaselect/leaflet-areaselect-tests.ts b/types/leaflet-areaselect/leaflet-areaselect-tests.ts
index b5d4785257..e285a17432 100644
--- a/types/leaflet-areaselect/leaflet-areaselect-tests.ts
+++ b/types/leaflet-areaselect/leaflet-areaselect-tests.ts
@@ -1,6 +1,9 @@
+import * as L from 'leaflet';
+import 'leaflet-areaselect';
+
 const map = L.map('map', {center: L.latLng(-37.7772, 175.2756), zoom: 15 });
 let area: L.AreaSelect;
-let dim: L.Dimension = { width: 1, height: 2 };
+const dim: L.Dimension = { width: 1, height: 2 };
 
 area = L.areaSelect({});
 
diff --git a/types/leaflet-areaselect/tslint.json b/types/leaflet-areaselect/tslint.json
index d88586e5bd..4e88071852 100644
--- a/types/leaflet-areaselect/tslint.json
+++ b/types/leaflet-areaselect/tslint.json
@@ -1,3 +1 @@
-{
-  "extends": "dtslint/dt.json"
-}
+{"extends": "dtslint/dt.json"}
diff --git a/types/leaflet-curve/index.d.ts b/types/leaflet-curve/index.d.ts
index b15f701f81..58e4551dec 100644
--- a/types/leaflet-curve/index.d.ts
+++ b/types/leaflet-curve/index.d.ts
@@ -1,13 +1,13 @@
-// Type definitions for leaflet-curve 0.0.1
+// Type definitions for leaflet-curve 0.1
 // Project: https://github.com/onikiienko/Leaflet.curve
 // Definitions by: Onikiienko <https://github.com/onikiienko>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
 	/**
 	 * Drawing Bezier curves and other complex shapes.
 	 */
-	function  curve(path: any[], options?: L.PathOptions): Path;
+	function curve(path: any[], options?: PathOptions): Path;
 }
diff --git a/types/leaflet-curve/leaflet-curve-tests.ts b/types/leaflet-curve/leaflet-curve-tests.ts
index 3d8b319e63..7390f82b9d 100644
--- a/types/leaflet-curve/leaflet-curve-tests.ts
+++ b/types/leaflet-curve/leaflet-curve-tests.ts
@@ -1,29 +1,31 @@
-var osmUrl = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
-    osmAttrib = '&copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-    osm = L.tileLayer(osmUrl, {maxZoom: 18, attribution: osmAttrib}),
-    map = new L.Map('map', {layers: [osm], center: new L.LatLng(-37.7772, 175.2756), zoom: 15 }),
-    objectToSetOnMap = {
-        "color": "black",
-        start: {
-            x: 37.64903402157866,
-            y: -3.6474609375000004
-        },
-        vertex: {
-            x: 38.839707613545144,
-            y: -1.9555664062500002
-        },
-        end: {
-            x: 39.977120098439634,
-            y: -3.6474609375000004
-        }
-    };
+import * as L from 'leaflet';
+import 'leaflet-curve';
 
+const osmUrl = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
+const osmAttrib = '&copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap</a> contributors';
+const osm = L.tileLayer(osmUrl, {maxZoom: 18, attribution: osmAttrib});
+const map = new L.Map('map', {layers: [osm], center: new L.LatLng(-37.7772, 175.2756), zoom: 15 });
+const objectToSetOnMap = {
+    color: 'black',
+    start: {
+        x: 37.64903402157866,
+        y: -3.6474609375000004
+    },
+    vertex: {
+        x: 38.839707613545144,
+        y: -1.9555664062500002
+    },
+    end: {
+        x: 39.977120098439634,
+        y: -3.6474609375000004
+    }
+};
 
 L.curve(
     [
-        'M',[objectToSetOnMap.start.x, objectToSetOnMap.start.y],
-        'C',[objectToSetOnMap.start.x, objectToSetOnMap.start.y], [objectToSetOnMap.vertex.x, objectToSetOnMap.vertex.y], [objectToSetOnMap.end.x, objectToSetOnMap.end.y],
-        'T',[objectToSetOnMap.end.x, objectToSetOnMap.end.y]
+        'M', [objectToSetOnMap.start.x, objectToSetOnMap.start.y],
+        'C', [objectToSetOnMap.start.x, objectToSetOnMap.start.y], [objectToSetOnMap.vertex.x, objectToSetOnMap.vertex.y], [objectToSetOnMap.end.x, objectToSetOnMap.end.y],
+        'T', [objectToSetOnMap.end.x, objectToSetOnMap.end.y]
     ],
     {color: objectToSetOnMap.color}
 ).addTo(map);
diff --git a/types/leaflet-curve/tslint.json b/types/leaflet-curve/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/leaflet-curve/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/leaflet-draw/index.d.ts b/types/leaflet-draw/index.d.ts
index 7d791f62ae..5ae8c81605 100644
--- a/types/leaflet-draw/index.d.ts
+++ b/types/leaflet-draw/index.d.ts
@@ -2,10 +2,11 @@
 // Project: https://github.com/Leaflet/Leaflet.draw
 // Definitions by: Matt Guest <https://github.com/matt-guest>, Ryan Blace <https://github.com/reblace>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
 	interface MapOptions {
 		drawControl?: boolean;
 	}
diff --git a/types/leaflet-draw/leaflet-draw-tests.ts b/types/leaflet-draw/leaflet-draw-tests.ts
index 80e175732f..e63006edce 100644
--- a/types/leaflet-draw/leaflet-draw-tests.ts
+++ b/types/leaflet-draw/leaflet-draw-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet-draw';
+
 const osmUrl = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
 const osmAttrib = '&copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap</a> contributors';
 const osm = L.tileLayer(osmUrl, {maxZoom: 18, attribution: osmAttrib});
@@ -42,8 +45,8 @@ map.on(L.Draw.Event.CREATED, (e: L.DrawEvents.Created) => {
     drawnItems.addLayer(layer);
 });
 
-let examplePolygon: L.LatLngLiteral[] = [{lng: 0, lat: 0}, {lng: 10, lat: 0}, {lng: 10, lat: 10}, {lng: 0, lat: 10}, {lng: 0, lat: 0}];
-let examplePolygonArea: number = L.GeometryUtil.geodesicArea(examplePolygon);
+const examplePolygon: L.LatLngLiteral[] = [{lng: 0, lat: 0}, {lng: 10, lat: 0}, {lng: 10, lat: 10}, {lng: 0, lat: 10}, {lng: 0, lat: 0}];
+const examplePolygonArea: number = L.GeometryUtil.geodesicArea(examplePolygon);
 L.GeometryUtil.readableArea(examplePolygonArea, true);
 
 function testBooleanControlOptions() {
@@ -104,7 +107,7 @@ function testExampleControlOptions() {
             circle: false, // Turns off this drawing tool
             rectangle: {
                 shapeOptions: {
-                    clickable: false
+                    // clickable: false // clickabkle is not a polyline option according to leaflet docs
                 }
             },
             marker: {
diff --git a/types/leaflet-editable/index.d.ts b/types/leaflet-editable/index.d.ts
index f66b45a9b8..ee42cb1fb1 100644
--- a/types/leaflet-editable/index.d.ts
+++ b/types/leaflet-editable/index.d.ts
@@ -2,38 +2,39 @@
 // Project: https://github.com/yohanboniface/Leaflet.Editable
 // Definitions by: Dominic Alie <https://github.com/dalie>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
-import * as Leaflet from "leaflet";
+import * as Leaflet from 'leaflet';
 
-declare global { namespace L {
+declare module 'leaflet' {
     /**
      * Make geometries editable in Leaflet.
      *
      * This is not a plug and play UI, and will not. This is a minimal, lightweight, and fully extendable API to
      * control editing of geometries. So you can easily build your own UI with your own needs and choices.
      */
-    export interface EditableStatic {
+    interface EditableStatic {
         new (map: Map, options: EditOptions): Editable;
     }
 
     /**
      * Options to pass to L.Editable when instanciating.
      */
-    export interface EditOptions {
+    interface EditOptions {
         /**
          * Class to be used when creating a new Polyline.
          */
-        polylineClass?: Object;
+        polylineClass?: object;
 
         /**
          * Class to be used when creating a new Polygon.
          */
-        polygonClass?: Object;
+        polygonClass?: object;
 
         /**
          * Class to be used when creating a new Marker.
          */
-        markerClass?: Object;
+        markerClass?: object;
 
         /**
          * CSS class to be added to the map container while drawing.
@@ -43,42 +44,42 @@ declare global { namespace L {
         /**
          * Layer used to store edit tools (vertex, line guide…).
          */
-        editLayer?: Leaflet.LayerGroup<Leaflet.ILayer>;
+        editLayer?: LayerGroup<ILayer>;
 
         /**
          * Default layer used to store drawn features (marker, polyline…).
          */
-        featuresLayer?: Leaflet.LayerGroup<L.Polyline|L.Polygon|L.Marker>;
+        featuresLayer?: LayerGroup<Polyline|Polygon|Marker>;
 
         /**
          * Class to be used as vertex, for path editing.
          */
-        vertexMarkerClass?: Object;
+        vertexMarkerClass?: object;
 
         /**
          * Class to be used as middle vertex, pulled by the user to create a new point in the middle of a path.
          */
-        middleMarkerClass?: Object;
+        middleMarkerClass?: object;
 
         /**
          * Class to be used as Polyline editor.
          */
-        polylineEditorClass?: Object;
+        polylineEditorClass?: object;
 
         /**
          * Class to be used as Polygon editor.
          */
-        polygonEditorClass?: Object;
+        polygonEditorClass?: object;
 
         /**
          * Class to be used as Marker editor.
          */
-        markerEditorClass?: Object;
+        markerEditorClass?: object;
 
         /**
          * Options to be passed to the line guides.
          */
-        lineGuideOptions?: Object;
+        lineGuideOptions?: object;
 
         /**
          * Set this to true if you don't want middle markers.
@@ -92,7 +93,7 @@ declare global { namespace L {
      * This is not a plug and play UI, and will not. This is a minimal, lightweight, and fully extendable API to
      * control editing of geometries. So you can easily build your own UI with your own needs and choices.
      */
-    export interface Editable extends Mixin.LeafletMixinEvents {
+    interface Editable extends Mixin.LeafletMixinEvents {
         /**
          * Options to pass to L.Editable when instanciating.
          */
@@ -104,20 +105,20 @@ declare global { namespace L {
          * Start drawing a polyline. If latlng is given, a first point will be added. In any case, continuing on user
          * click. If options is given, it will be passed to the polyline class constructor.
          */
-        startPolyline(latLng?: LatLng, options?: Leaflet.PolylineOptions): L.Polyline;
+        startPolyline(latLng?: LatLng, options?: PolylineOptions): Polyline;
 
         /**
          * Start drawing a polygon. If latlng is given, a first point will be added. In any case, continuing on user
          * click. If options is given, it will be passed to the polygon class constructor.
          */
-        startPolygon(latLng?: LatLng, options?: Leaflet.PolylineOptions): L.Polygon;
+        startPolygon(latLng?: LatLng, options?: PolylineOptions): Polygon;
 
         /**
          * Start adding a marker. If latlng is given, the marker will be shown first at this point. In any case, it
          * will follow the user mouse, and will have a final latlng on next click (or touch). If options is given,
          * it will be passed to the marker class constructor.
          */
-        startMarker(latLng?: LatLng, options?: Leaflet.MarkerOptions): L.Marker;
+        startMarker(latLng?: LatLng, options?: MarkerOptions): Marker;
 
         /**
          * When you need to stop any ongoing drawing, without needing to know which editor is active.
@@ -125,14 +126,14 @@ declare global { namespace L {
         stopDrawing(): void;
     }
 
-    export var Editable: EditableStatic;
+    let Editable: EditableStatic;
 
     /**
      * EditableMixin is included to L.Polyline, L.Polygon and L.Marker. It adds the following methods to them.
      *
      * When editing is enabled, the editor is accessible on the instance with the editor property.
      */
-    export interface EditableMixin {
+    interface EditableMixin {
         /**
          * Enable editing, by creating an editor if not existing, and then calling enable on it.
          */
@@ -154,7 +155,7 @@ declare global { namespace L {
         editEnabled(): boolean;
     }
 
-    export interface Map {
+    interface Map {
         /**
          * Whether to create a L.Editable instance at map init or not.
          */
@@ -171,11 +172,11 @@ declare global { namespace L {
         editTools: Editable;
     }
 
-    export interface Polyline extends EditableMixin {
-    }
+    // tslint:disable-next-line:no-empty-interface
+    interface Polyline extends EditableMixin {}
 
     namespace Map {
-        export interface MapOptions {
+        interface MapOptions {
             /**
              * Whether to create a L.Editable instance at map init or not.
              */
@@ -192,7 +193,7 @@ declare global { namespace L {
      * When editing a feature (marker, polyline…), an editor is attached to it. This editor basically knows
      * how to handle the edition.
      */
-    export interface BaseEditor {
+    interface BaseEditor {
         /**
          * Set up the drawing tools for the feature to be editable.
          */
@@ -208,7 +209,7 @@ declare global { namespace L {
      * Inherit from L.Editable.BaseEditor.
      * Inherited by L.Editable.PolylineEditor and L.Editable.PolygonEditor.
      */
-    export interface PathEditor extends BaseEditor {
+    interface PathEditor extends BaseEditor {
         /**
          * Rebuild edit elements (vertex, middlemarker, etc.).
          */
@@ -218,7 +219,7 @@ declare global { namespace L {
     /**
      * Inherit from L.Editable.PathEditor.
      */
-    export interface PolylineEditor extends PathEditor {
+    interface PolylineEditor extends PathEditor {
         /**
          * Set up drawing tools to continue the line forward.
          */
@@ -233,7 +234,7 @@ declare global { namespace L {
     /**
      * Inherit from L.Editable.PathEditor.
      */
-    export interface PolygonEditor extends PathEditor {
+    interface PolygonEditor extends PathEditor {
         /**
          * Set up drawing tools for creating a new hole on the polygon. If the latlng param is given, a first
          * point is created.
@@ -244,15 +245,12 @@ declare global { namespace L {
     /**
      * Inherit from L.Editable.BaseEditor.
      */
-    export interface MarkerEditor extends BaseEditor {
-    }
+    // tslint:disable-next-line:no-empty-interface
+    interface MarkerEditor extends BaseEditor {}
 
-    export interface Marker extends EditableMixin, MarkerEditor {
-    }
+    interface Marker extends EditableMixin, MarkerEditor {}
 
-    export interface Polyline extends EditableMixin, PolylineEditor {
-    }
+    interface Polyline extends EditableMixin, PolylineEditor {}
 
-    export interface Polygon extends EditableMixin, PolygonEditor {
-    }
-} }
+    interface Polygon extends EditableMixin, PolygonEditor {}
+}
diff --git a/types/leaflet-editable/leaflet-editable-tests.ts b/types/leaflet-editable/leaflet-editable-tests.ts
index 09728add47..23bcc988fb 100644
--- a/types/leaflet-editable/leaflet-editable-tests.ts
+++ b/types/leaflet-editable/leaflet-editable-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet-editable';
+
 class MarkerClass { }
 class MarkerEditorClass { }
 class MiddleMarkerClass { }
@@ -7,7 +10,7 @@ class PolylineClass { }
 class PolylineEditorClass { }
 class VertexMarkerClass { }
 
-var map: L.Map = L.map('div', {
+const map: L.Map = L.map('div', {
     editable: true,
     editOptions: {
         drawingCSSClass: 'css-class',
@@ -26,16 +29,16 @@ var map: L.Map = L.map('div', {
     }
 });
 
-var currentPoly: L.Polygon|L.Polyline| L.Marker = map.editTools.currentPolygon;
+const currentPoly: L.Polygon|L.Polyline| L.Marker = map.editTools.currentPolygon;
 map.editTools.stopDrawing();
 
-var marker: L.Marker = map.editTools.startMarker(L.latLng(0, 0), { draggable: true });
+const marker: L.Marker = map.editTools.startMarker(L.latLng(0, 0), { draggable: true });
 marker.disable();
 marker.enable();
 marker.toggleEdit();
-var enabled: boolean = marker.editEnabled();
+let enabled: boolean = marker.editEnabled();
 
-var polyline: L.Polyline = map.editTools.startPolyline(L.latLng(0, 0), { noClip: true });
+const polyline: L.Polyline = map.editTools.startPolyline(L.latLng(0, 0), { noClip: true });
 polyline.continueBackward();
 polyline.continueForward();
 polyline.disable();
@@ -44,7 +47,7 @@ enabled = polyline.editEnabled();
 polyline.reset();
 polyline.toggleEdit();
 
-var polygon: L.Polygon = map.editTools.startPolygon(L.latLng(0, 0), { noClip: true });
+const polygon: L.Polygon = map.editTools.startPolygon(L.latLng(0, 0), { noClip: true });
 polygon.continueBackward();
 polygon.continueForward();
 polygon.disable();
diff --git a/types/leaflet-editable/tslint.json b/types/leaflet-editable/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/leaflet-editable/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/leaflet-fullscreen/index.d.ts b/types/leaflet-fullscreen/index.d.ts
index 168fae8a28..bf354e9155 100644
--- a/types/leaflet-fullscreen/index.d.ts
+++ b/types/leaflet-fullscreen/index.d.ts
@@ -3,9 +3,9 @@
 // Definitions by: Denis Carriere <https://github.com/DenisCarriere>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
     interface MapOptions {
         fullscreenControl?: true | {pseudoFullscreen: boolean};
     }
diff --git a/types/leaflet-fullscreen/leaflet-fullscreen-tests.ts b/types/leaflet-fullscreen/leaflet-fullscreen-tests.ts
index 661f1bc208..efc611c193 100644
--- a/types/leaflet-fullscreen/leaflet-fullscreen-tests.ts
+++ b/types/leaflet-fullscreen/leaflet-fullscreen-tests.ts
@@ -1,3 +1,5 @@
+import * as L from 'leaflet';
+
 const map = L.map('map', {
     center: [51.505, -0.09],
     zoom: 13,
diff --git a/types/leaflet-fullscreen/tslint.json b/types/leaflet-fullscreen/tslint.json
index f93cf8562a..4e88071852 100644
--- a/types/leaflet-fullscreen/tslint.json
+++ b/types/leaflet-fullscreen/tslint.json
@@ -1,3 +1 @@
-{
-    "extends": "dtslint/dt.json"
-}
+{"extends": "dtslint/dt.json"}
diff --git a/types/leaflet-geocoder-mapzen/index.d.ts b/types/leaflet-geocoder-mapzen/index.d.ts
index 390a751360..d4f8b445d9 100644
--- a/types/leaflet-geocoder-mapzen/index.d.ts
+++ b/types/leaflet-geocoder-mapzen/index.d.ts
@@ -1,23 +1,24 @@
-// Type definitions for leaflet-geocoder-mapzen v1.6.3
+// Type definitions for leaflet-geocoder-mapzen 1.6
 // Project: https://github.com/mapzen/leaflet-geocoder
-// Definitions by: Leonard Lausen <http://leonard.lausen.nl/>
+// Definitions by: Leonard Lausen <https://github.com/leezu>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
-import * as Leaflet from "leaflet";
+import * as L from 'leaflet';
 
-declare global { namespace L {
+declare module 'leaflet' {
     namespace Control {
-        export interface GeocoderStatic extends Leaflet.ClassStatic {
+        interface GeocoderStatic extends ClassStatic {
             /**
              * Creates a geocoder control.
              */
             new (options?: GeocoderOptions): Geocoder;
         }
 
-        export interface Geocoder extends Leaflet.Control {
-        }
+        // tslint:disable-next-line:no-empty-interface
+        interface Geocoder extends Control {}
 
-        export interface GeocoderOptions {
+        interface GeocoderOptions {
             /**
              * Host endpoint for a Pelias-compatible search API.
              *
@@ -32,7 +33,7 @@ declare global { namespace L {
              *
              * Default value: false.
              */
-            bounds?: Leaflet.LatLngBounds | boolean;
+            bounds?: LatLngBounds | boolean;
 
             /**
              * If true, search and autocomplete prioritizes results near the center
@@ -42,7 +43,7 @@ declare global { namespace L {
              *
              * Default value: 'true'.
              */
-            focus?: Leaflet.LatLng | boolean;
+            focus?: LatLng | boolean;
 
             /**
              * Filters results by layers (documentation).
@@ -69,7 +70,7 @@ declare global { namespace L {
              *
              * Default value: null.
              */
-            params?: Object;
+            params?: object;
 
             /**
              * The position of the control (one of the map corners).
@@ -77,7 +78,7 @@ declare global { namespace L {
              *
              * Default value: 'topleft'.
              */
-            position?: Leaflet.PositionString;
+            position?: PositionString;
 
             /**
              * Attribution text to include.
@@ -126,7 +127,7 @@ declare global { namespace L {
              *
              * Default value: true
              */
-            markers?: Leaflet.MarkerOptions | boolean;
+            markers?: MarkerOptions | boolean;
 
             /**
              * If true, the input box will expand to take up the full width of the map container.
@@ -166,11 +167,10 @@ declare global { namespace L {
         }
     }
 
-    export namespace control {
-
+    namespace control {
         /**
          * Creates a geocoder control.
          */
-        export function geocoder(api_key: string, options?: Control.GeocoderOptions): L.Control.Geocoder;
+        function geocoder(api_key: string, options?: Control.GeocoderOptions): Control.Geocoder;
     }
-} }
+}
diff --git a/types/leaflet-geocoder-mapzen/leaflet-geocoder-mapzen-tests.ts b/types/leaflet-geocoder-mapzen/leaflet-geocoder-mapzen-tests.ts
index daf6d20bd6..92bb68f1a9 100644
--- a/types/leaflet-geocoder-mapzen/leaflet-geocoder-mapzen-tests.ts
+++ b/types/leaflet-geocoder-mapzen/leaflet-geocoder-mapzen-tests.ts
@@ -1,7 +1,10 @@
-var osmUrl = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
-    osmAttrib = '&copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-    osm = L.tileLayer(osmUrl, {maxZoom: 18, attribution: osmAttrib}),
-    map = new L.Map('map', {layers: [osm], center: new L.LatLng(-37.7772, 175.2756), zoom: 15 });
+import * as L from 'leaflet';
+import 'leaflet-geocoder-mapzen';
+
+const osmUrl = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
+const osmAttrib = '&copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap</a> contributors';
+const osm = L.tileLayer(osmUrl, {maxZoom: 18, attribution: osmAttrib});
+const map = new L.Map('map', {layers: [osm], center: new L.LatLng(-37.7772, 175.2756), zoom: 15 });
 
 // Add geocoding plugin
 L.control.geocoder('search-MKZrG6M').addTo(map);
diff --git a/types/leaflet-geocoder-mapzen/tslint.json b/types/leaflet-geocoder-mapzen/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/leaflet-geocoder-mapzen/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/leaflet-imageoverlay-rotated/index.d.ts b/types/leaflet-imageoverlay-rotated/index.d.ts
index 89dde5e375..6a37345ca5 100644
--- a/types/leaflet-imageoverlay-rotated/index.d.ts
+++ b/types/leaflet-imageoverlay-rotated/index.d.ts
@@ -3,11 +3,11 @@
 // Definitions by: Thomas Kleinke <https://github.com/tkleinke>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
     namespace ImageOverlay {
-        interface Rotated extends L.ImageOverlay {
+        interface Rotated extends ImageOverlay {
             reposition(
                 topleft: LatLngExpression,
                 topright: LatLngExpression,
@@ -21,6 +21,6 @@ declare namespace L {
             topleft: LatLngExpression,
             topright: LatLngExpression,
             bottomleft: LatLngExpression,
-            options?: ImageOverlayOptions): L.ImageOverlay.Rotated;
+            options?: ImageOverlayOptions): ImageOverlay.Rotated;
     }
 }
diff --git a/types/leaflet-imageoverlay-rotated/leaflet-imageoverlay-rotated-tests.ts b/types/leaflet-imageoverlay-rotated/leaflet-imageoverlay-rotated-tests.ts
index 50db445f79..22b4a54ec1 100644
--- a/types/leaflet-imageoverlay-rotated/leaflet-imageoverlay-rotated-tests.ts
+++ b/types/leaflet-imageoverlay-rotated/leaflet-imageoverlay-rotated-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet-imageoverlay-rotated';
+
 const topleft = L.latLng(40.52256691873593, -3.7743186950683594);
 const topright = L.latLng(40.5210255066156, -3.7734764814376835);
 const bottomleft = L.latLng(40.52180437272552, -3.7768453359603886);
diff --git a/types/leaflet-label/index.d.ts b/types/leaflet-label/index.d.ts
index e1e96b717a..60f2b6b398 100644
--- a/types/leaflet-label/index.d.ts
+++ b/types/leaflet-label/index.d.ts
@@ -3,83 +3,79 @@
 // Definitions by: Wim Looman <https://github.com/Nemo157>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-import * as Leaflet from "leaflet";
+import * as L from 'leaflet';
 
-declare global {
-	namespace L {
-		interface IconOptions {
-			labelAnchor?: Point;
-		}
+declare module 'leaflet' {
+	interface IconOptions {
+		labelAnchor?: Point;
+	}
 
-		interface PathOptions {
-			labelAnchor?: Point;
-		}
+	interface PathOptions {
+		labelAnchor?: Point;
+	}
 
-		interface CircleMarkerOptions {
-			labelAnchor?: Point;
-		}
+	interface CircleMarkerOptions {
+		labelAnchor?: Point;
+	}
 
-		interface Marker {
-			showLabel(): Marker;
-			hideLabel(): Marker;
-			setLabelNoHide(noHide: boolean): void;
-			bindLabel(content: string, options?: LabelOptions): Marker;
-			unbindLabel(): Marker;
-			updateLabelContent(content: string): void;
-			getLabel(): Label;
-			setOpacity(opacity: number, labelHasSemiTransparency: boolean): void;
-		}
+	interface Marker {
+		showLabel(): Marker;
+		hideLabel(): Marker;
+		setLabelNoHide(noHide: boolean): void;
+		bindLabel(content: string, options?: LabelOptions): Marker;
+		unbindLabel(): Marker;
+		updateLabelContent(content: string): void;
+		getLabel(): Label;
+		setOpacity(opacity: number, labelHasSemiTransparency: boolean): void;
+	}
 
-		interface CircleMarker {
-			showLabel(): CircleMarker;
-			hideLabel(): CircleMarker;
-			setLabelNoHide(noHide: boolean): void;
-			bindLabel(content: string, options?: LabelOptions): CircleMarker;
-			unbindLabel(): CircleMarker;
-			updateLabelContent(content: string): void;
-			getLabel(): Label;
-		}
+	interface CircleMarker {
+		showLabel(): CircleMarker;
+		hideLabel(): CircleMarker;
+		setLabelNoHide(noHide: boolean): void;
+		bindLabel(content: string, options?: LabelOptions): CircleMarker;
+		unbindLabel(): CircleMarker;
+		updateLabelContent(content: string): void;
+		getLabel(): Label;
+	}
 
-		interface FeatureGroup<T extends ILayer> {
-			clearLayers(): FeatureGroup<T>;
-			bindLabel(content: string, options?: LabelOptions): FeatureGroup<T>;
-			unbindLabel(): FeatureGroup<T>;
-			updateLabelContent(content: string): FeatureGroup<T>;
-		}
+	interface FeatureGroup<T extends ILayer> {
+		clearLayers(): FeatureGroup<T>;
+		bindLabel(content: string, options?: LabelOptions): FeatureGroup<T>;
+		unbindLabel(): FeatureGroup<T>;
+		updateLabelContent(content: string): FeatureGroup<T>;
+	}
 
-		interface Path {
-			bindLabel(content: string, options?: LabelOptions): Path;
-			unbindLabel(): Path;
-			updateLabelContent(content: string): void;
-		}
+	interface Path {
+		bindLabel(content: string, options?: LabelOptions): Path;
+		unbindLabel(): Path;
+		updateLabelContent(content: string): void;
+	}
 
-		interface LabelOptions {
-			className?: string;
-			clickable?: boolean;
-			direction?: string; // 'left' | 'right' | 'auto';
-			pane?: string;
-			noHide?: boolean;
-			offset?: Point;
-			opacity?: number;
-			zoomAnimation?: boolean;
-		}
+	interface LabelOptions {
+		className?: string;
+		clickable?: boolean;
+		direction?: string; // 'left' | 'right' | 'auto';
+		pane?: string;
+		noHide?: boolean;
+		offset?: Point;
+		opacity?: number;
+		zoomAnimation?: boolean;
+	}
 
-		interface LabelStatic extends ClassStatic {
-			new(options?: LabelOptions): Label;
-		}
+	interface LabelStatic extends ClassStatic {
+		new(options?: LabelOptions): Label;
+	}
 
-		const Label: LabelStatic;
+	const Label: LabelStatic;
 
-		interface Label extends IEventPowered<Label> {
-			onAdd(map: Map): void;
-			onRemove(map: Map): void;
-			setLatLng(latlng: LatLng): Label;
-			setContent(content: string): Label;
-			close(): void;
-			updateZIndex(zIndex: number): void;
-			setOpacity(opacity: number): void;
-		}
+	interface Label extends IEventPowered<Label> {
+		onAdd(map: Map): void;
+		onRemove(map: Map): void;
+		setLatLng(latlng: LatLng): Label;
+		setContent(content: string): Label;
+		close(): void;
+		updateZIndex(zIndex: number): void;
+		setOpacity(opacity: number): void;
 	}
 }
-
-export = L;
diff --git a/types/leaflet-label/leaflet-label-tests.ts b/types/leaflet-label/leaflet-label-tests.ts
index da163cffd9..0c39fde63c 100644
--- a/types/leaflet-label/leaflet-label-tests.ts
+++ b/types/leaflet-label/leaflet-label-tests.ts
@@ -1,4 +1,7 @@
-let map: L.Map;
+import * as L from 'leaflet';
+import 'leaflet-label';
+
+const map: L.Map = L.map('map-container');
 let label: L.Label;
 
 // Icon
diff --git a/types/leaflet-polylinedecorator/index.d.ts b/types/leaflet-polylinedecorator/index.d.ts
index 30256f1ea5..b3603e9f29 100644
--- a/types/leaflet-polylinedecorator/index.d.ts
+++ b/types/leaflet-polylinedecorator/index.d.ts
@@ -2,10 +2,11 @@
 // Project: https://github.com/bbecquet/Leaflet.PolylineDecorator#readme
 // Definitions by: Viktor Soucek <https://github.com/soucekv>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
     namespace Symbol {
         interface DashOptions {
             pixelSize?: number;
diff --git a/types/leaflet-polylinedecorator/leaflet-polylinedecorator-tests.ts b/types/leaflet-polylinedecorator/leaflet-polylinedecorator-tests.ts
index 19bf57e6bd..7a9c5ee946 100644
--- a/types/leaflet-polylinedecorator/leaflet-polylinedecorator-tests.ts
+++ b/types/leaflet-polylinedecorator/leaflet-polylinedecorator-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet-polylinedecorator';
+
 const osmUrl = 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png';
 const osmAttrib = '&copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap</a> contributors';
 const osm = L.tileLayer(osmUrl, {maxZoom: 18, attribution: osmAttrib});
diff --git a/types/leaflet-providers/index.d.ts b/types/leaflet-providers/index.d.ts
index 537d9d5574..aa5af026a1 100644
--- a/types/leaflet-providers/index.d.ts
+++ b/types/leaflet-providers/index.d.ts
@@ -3,9 +3,9 @@
 // Definitions by: BendingBender <https://github.com/BendingBender>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
   namespace TileLayer {
     class Provider extends TileLayer {
       constructor(provider: string, options?: TileLayerOptions)
@@ -21,7 +21,7 @@ declare namespace L {
       interface ProviderConfig {
         url: string;
         options?: TileLayerOptions;
-        variants?: { [variantName: string]: string | ProviderConfig };
+        variants?: {[variantName: string]: string | ProviderConfig};
       }
     }
   }
diff --git a/types/leaflet-providers/leaflet-providers-tests.ts b/types/leaflet-providers/leaflet-providers-tests.ts
index 5ab91e5b92..eecff562af 100644
--- a/types/leaflet-providers/leaflet-providers-tests.ts
+++ b/types/leaflet-providers/leaflet-providers-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet-providers';
+
 const map = L.map('map');
 L.tileLayer.provider('Stamen.Watercolor').addTo(map);
 
diff --git a/types/leaflet.awesome-markers/index.d.ts b/types/leaflet.awesome-markers/index.d.ts
index ece7b26076..859a37364b 100644
--- a/types/leaflet.awesome-markers/index.d.ts
+++ b/types/leaflet.awesome-markers/index.d.ts
@@ -1,51 +1,51 @@
-// Type definitions for Leaflet.awesome-markers plugin v2.0
+// Type definitions for Leaflet.awesome-markers plugin 2.0
 // Project: https://github.com/sigma-geosistemas/Leaflet.awesome-markers#properties
 // Definitions by: Marcel Sebek <https://github.com/sebek64>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
 import * as Leaflet from "leaflet";
 
-declare global { namespace L {
-    module AwesomeMarkers {
-        var version: string;
+declare module 'leaflet' {
+    namespace AwesomeMarkers {
+        const version: string;
 
-        function icon(options: AwesomeMarkers.IconOptions): AwesomeMarkers.Icon;
-
-        class Icon extends Leaflet.BaseIcon {
-            constructor(options?: AwesomeMarkers.IconOptions);
-            options: AwesomeMarkers.IconOptions;
-        }
-
-        interface IconOptions extends Leaflet.BaseIconOptions {
+        interface AwesomeMarkersIconOptions extends BaseIconOptions {
             /**
-            * Name of the icon. See glyphicons or font-awesome.
-            */
+             * Name of the icon. See glyphicons or font-awesome.
+             */
             icon?: string;
 
             /**
-            * Select de icon library. 'fa' for font-awesome or 'glyphicon' for bootstrap 3.
-            */
+             * Select de icon library. 'fa' for font-awesome or 'glyphicon' for bootstrap 3.
+             */
             prefix?: 'fa' | 'glyphicon';
 
             /**
-            * Color of the marker
-            */
+             * Color of the marker
+             */
             markerColor?: 'red' | 'darkred' | 'orange' | 'green' | 'darkgreen' | 'blue' | 'purple' | 'darkpurple' | 'cadetblue';
 
             /**
-            * Color of the icon. 'white', 'black' or css code (hex, rgba etc).
-            */
+             * Color of the icon. 'white', 'black' or css code (hex, rgba etc).
+             */
             iconColor?: 'white' | 'black' | string;
 
             /**
-            * Make the icon spin. true or false. Font-awesome required
-            */
+             * Make the icon spin. true or false. Font-awesome required
+             */
             spin?: boolean;
 
             /**
-            * Additional classes in the created tag
-            */
+             * Additional classes in the created tag
+             */
             extraClasses?: string;
         }
+
+        function icon(options: AwesomeMarkersIconOptions): Icon;
+
+        class Icon extends Leaflet.Icon<AwesomeMarkersIconOptions> {
+            constructor(options?: AwesomeMarkersIconOptions);
+        }
     }
-} }
+}
diff --git a/types/leaflet.awesome-markers/leaflet.awesome-markers-tests.ts b/types/leaflet.awesome-markers/leaflet.awesome-markers-tests.ts
index 1183cad3f3..438787463f 100644
--- a/types/leaflet.awesome-markers/leaflet.awesome-markers-tests.ts
+++ b/types/leaflet.awesome-markers/leaflet.awesome-markers-tests.ts
@@ -1,13 +1,14 @@
+import * as L from 'leaflet';
+import 'leaflet.awesome-markers';
 
+const map: L.Map = L.map('map-container');
 
-var map: L.Map;
-
-var redMarker = L.AwesomeMarkers.icon({
+const redMarker = L.AwesomeMarkers.icon({
     icon: 'coffee',
     markerColor: 'red'
 });
 
-var blueMarker = new L.AwesomeMarkers.Icon({
+const blueMarker = new L.AwesomeMarkers.Icon({
     icon: 'star',
     markerColor: 'blue'
 });
diff --git a/types/leaflet.awesome-markers/tslint.json b/types/leaflet.awesome-markers/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/leaflet.awesome-markers/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/leaflet.fullscreen/index.d.ts b/types/leaflet.fullscreen/index.d.ts
index e38890b2d8..bc5abc85d2 100644
--- a/types/leaflet.fullscreen/index.d.ts
+++ b/types/leaflet.fullscreen/index.d.ts
@@ -1,35 +1,32 @@
-// Type definitions for Leaflet.fullscreen v1.3.0
+// Type definitions for Leaflet.fullscreen 1.3
 // Project: https://github.com/brunob/leaflet.fullscreen
 // Definitions by: William Comartin <https://github.com/wcomartin>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
-
-declare namespace L {
+import * as L from 'leaflet';
 
+declare module 'leaflet' {
   namespace Control {
-
-    export class Fullscreen extends L.Control {
-      constructor(options?: Control.FullscreenOptions);
+    class Fullscreen extends L.Control {
+      constructor(options?: FullscreenOptions);
       options: FullscreenOptions;
     }
-    export interface FullscreenOptions {
-      content?: string,
-      position?: L.ControlPosition,
-      title?: string,
-      titleCancel?: string,
-      forceSeparateButton?: boolean,
-      forcePseudoFullscreen?: boolean,
-      pseudoFullscreen?:boolean
+
+    interface FullscreenOptions {
+      content?: string;
+      position?: ControlPosition;
+      title?: string;
+      titleCancel?: string;
+      forceSeparateButton?: boolean;
+      forcePseudoFullscreen?: boolean;
+      pseudoFullscreen?: boolean;
     }
   }
 
   namespace control {
-
     /**
      * Creates a fullscreen control.
      */
-    export function fullscreen(options?: Control.FullscreenOptions): L.Control.Fullscreen;
-
+    function fullscreen(options?: Control.FullscreenOptions): L.Control.Fullscreen;
   }
 }
diff --git a/types/leaflet.fullscreen/leaflet.fullscreen-tests.ts b/types/leaflet.fullscreen/leaflet.fullscreen-tests.ts
index 80b1440c2f..e118e5b233 100644
--- a/types/leaflet.fullscreen/leaflet.fullscreen-tests.ts
+++ b/types/leaflet.fullscreen/leaflet.fullscreen-tests.ts
@@ -1,9 +1,10 @@
+import * as L from 'leaflet';
+import 'leaflet.fullscreen';
 
-
-var map: L.Map;
+const map: L.Map = L.map('map-container');
 
 // Defaults
-var icon: L.Control.Fullscreen = L.control.fullscreen({
+const icon: L.Control.Fullscreen = L.control.fullscreen({
   position: 'topleft',
   title: 'Full Screen',
   titleCancel: 'Exit Full Screen',
@@ -13,9 +14,7 @@ var icon: L.Control.Fullscreen = L.control.fullscreen({
 
 icon.addTo(map);
 
-
 // My Usage
-
 L.control.fullscreen({
   position: 'topleft',
   content: '<i class="fa fa-arrows-alt"></i>',
diff --git a/types/leaflet.fullscreen/tslint.json b/types/leaflet.fullscreen/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/leaflet.fullscreen/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/leaflet.gridlayer.googlemutant/index.d.ts b/types/leaflet.gridlayer.googlemutant/index.d.ts
index d33ef977eb..00fd9fdce0 100644
--- a/types/leaflet.gridlayer.googlemutant/index.d.ts
+++ b/types/leaflet.gridlayer.googlemutant/index.d.ts
@@ -3,75 +3,77 @@
 // Definitions by: Ernest Rhinozeros <https://github.com/ernest-rhinozeros>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L.gridLayer {
-    interface GoogleMutant extends GridLayer {
-        setElementSize(e: HTMLElement, size: Point): void ;
+declare module 'leaflet' {
+    namespace gridLayer {
+        interface GoogleMutant extends GridLayer {
+            setElementSize(e: HTMLElement, size: Point): void ;
+        }
+
+        type GoogleMutantType = 'roadmap' | 'satellite' | 'terrain' | 'hybrid';
+
+        interface GoogleMutantStyler {
+            hue?: string;
+            lightness?: number;
+            saturation?: number;
+            gamma?: number;
+            invert_lightness?: boolean;
+            visibility?: string;
+            color?: string;
+            weight?: number;
+        }
+
+        /**
+         * Google's map style.
+         *
+         * https://developers.google.com/maps/documentation/javascript/style-reference
+         */
+        interface GoogleMutantStyle {
+            /**
+             * https://developers.google.com/maps/documentation/javascript/style-reference#style-features
+             */
+            featureType?: string;
+
+            /**
+             * https://developers.google.com/maps/documentation/javascript/style-reference#style-elements
+             */
+            elementType?: string;
+
+            /**
+             * https://developers.google.com/maps/documentation/javascript/style-reference#stylers
+             */
+            stylers?: GoogleMutantStyler[];
+        }
+
+        interface GoogleMutantOptions extends TileLayerOptions {
+            minZoom?: number;
+            maxZoom?: number;
+            maxNativeZoom?: number;
+            tileSize?: number | Point;
+            subdomains?: string | string[];
+            errorTileUrl?: string;
+
+            /**
+             * The mutant container will add its own attribution anyways.
+             */
+            attribution?: string;
+
+            opacity?: number;
+            continuousWorld?: boolean;
+            noWrap?: boolean;
+
+            /**
+             * Google's map type. 'hybrid' is not really supported.
+             */
+            type?: GoogleMutantType;
+
+            /**
+             * Google's map styles.
+             */
+            styles?: GoogleMutantStyle[];
+        }
+
+        function googleMutant(options?: GoogleMutantOptions): GoogleMutant;
     }
-
-    type GoogleMutantType = 'roadmap' | 'satellite' | 'terrain' | 'hybrid';
-
-    interface GoogleMutantStyler {
-        hue?: string;
-        lightness?: number;
-        saturation?: number;
-        gamma?: number;
-        invert_lightness?: boolean;
-        visibility?: string;
-        color?: string;
-        weight?: number;
-    }
-
-    /**
-     * Google's map style.
-     *
-     * https://developers.google.com/maps/documentation/javascript/style-reference
-     */
-    interface GoogleMutantStyle {
-        /**
-         * https://developers.google.com/maps/documentation/javascript/style-reference#style-features
-         */
-        featureType?: string;
-
-        /**
-         * https://developers.google.com/maps/documentation/javascript/style-reference#style-elements
-         */
-        elementType?: string;
-
-        /**
-         * https://developers.google.com/maps/documentation/javascript/style-reference#stylers
-         */
-        stylers?: GoogleMutantStyler[];
-    }
-
-    interface GoogleMutantOptions extends TileLayerOptions {
-        minZoom?: number;
-        maxZoom?: number;
-        maxNativeZoom?: number;
-        tileSize?: number | Point;
-        subdomains?: string | string[];
-        errorTileUrl?: string;
-
-        /**
-         * The mutant container will add its own attribution anyways.
-         */
-        attribution?: string;
-
-        opacity?: number;
-        continuousWorld?: boolean;
-        noWrap?: boolean;
-
-        /**
-         * Google's map type. 'hybrid' is not really supported.
-         */
-        type?: GoogleMutantType;
-
-        /**
-         * Google's map styles.
-         */
-        styles?: GoogleMutantStyle[];
-    }
-
-    function googleMutant(options?: GoogleMutantOptions): GoogleMutant;
 }
diff --git a/types/leaflet.gridlayer.googlemutant/leaflet.gridlayer.googlemutant-tests.ts b/types/leaflet.gridlayer.googlemutant/leaflet.gridlayer.googlemutant-tests.ts
index 797947f9c7..6bda5d2a5d 100644
--- a/types/leaflet.gridlayer.googlemutant/leaflet.gridlayer.googlemutant-tests.ts
+++ b/types/leaflet.gridlayer.googlemutant/leaflet.gridlayer.googlemutant-tests.ts
@@ -1,10 +1,13 @@
-let map = L.map('foo');
+import * as L from 'leaflet';
+import 'leaflet.gridlayer.googlemutant';
 
-let roads = L.gridLayer.googleMutant({
+const map = L.map('foo');
+
+const roads = L.gridLayer.googleMutant({
     type: 'roadmap'
 }).addTo(map);
 
-let styled = L.gridLayer.googleMutant({
+const styled = L.gridLayer.googleMutant({
     type: 'satellite',
     styles: [
         { elementType: 'labels', stylers: [ { visibility: 'off' } ] },
diff --git a/types/leaflet.locatecontrol/index.d.ts b/types/leaflet.locatecontrol/index.d.ts
index d5c5433e8e..5f561ca9ea 100644
--- a/types/leaflet.locatecontrol/index.d.ts
+++ b/types/leaflet.locatecontrol/index.d.ts
@@ -3,9 +3,9 @@
 // Definitions by: Denis Carriere <https://github.com/DenisCarriere>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
     namespace Control {
         interface LocateOptions {
             position?: string;
@@ -34,6 +34,7 @@ declare namespace L {
             locateOptions?: L.LocateOptions;
         }
     }
+
     namespace control {
         /**
          * Creates a Leaflet.Locate control
diff --git a/types/leaflet.locatecontrol/leaflet.locatecontrol-tests.ts b/types/leaflet.locatecontrol/leaflet.locatecontrol-tests.ts
index 59ab7f246f..fdca8f61ae 100644
--- a/types/leaflet.locatecontrol/leaflet.locatecontrol-tests.ts
+++ b/types/leaflet.locatecontrol/leaflet.locatecontrol-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet.locatecontrol';
+
 const map = L.map('map', {
     center: [51.505, -0.09],
     zoom: 13
diff --git a/types/leaflet.markercluster.layersupport/index.d.ts b/types/leaflet.markercluster.layersupport/index.d.ts
index 023142e752..21e33a1588 100644
--- a/types/leaflet.markercluster.layersupport/index.d.ts
+++ b/types/leaflet.markercluster.layersupport/index.d.ts
@@ -2,13 +2,12 @@
 // Project: https://github.com/ghybs/Leaflet.MarkerCluster.LayerSupport
 // Definitions by: AsamK <https://github.com/AsamK>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-import * as Leaflet from "leaflet";
-import * as MakerCluster from "leaflet.markercluster";
+import * as L from 'leaflet';
+import 'leaflet.markercluster';
 
-export = Leaflet;
-
-declare global { namespace L {
+declare module 'leaflet' {
     namespace MarkerClusterGroup {
         interface LayerSupport extends MarkerClusterGroup {
             /**
@@ -38,4 +37,4 @@ declare global { namespace L {
          */
         function layerSupport(options?: MarkerClusterGroupLayerSupportOptions): MarkerClusterGroup.LayerSupport;
     }
-} }
+}
diff --git a/types/leaflet.markercluster.layersupport/leaflet.markercluster.layersupport-tests.ts b/types/leaflet.markercluster.layersupport/leaflet.markercluster.layersupport-tests.ts
index 7b7faf3222..8a8995cfdf 100644
--- a/types/leaflet.markercluster.layersupport/leaflet.markercluster.layersupport-tests.ts
+++ b/types/leaflet.markercluster.layersupport/leaflet.markercluster.layersupport-tests.ts
@@ -1,4 +1,5 @@
-import L = require("leaflet.markercluster.layersupport");
+import * as L from 'leaflet';
+import 'leaflet.markercluster.layersupport';
 
 const polylineOptions: L.PolylineOptions = {};
 const icon: L.Icon = L.icon({ iconUrl: 'foo' });
diff --git a/types/leaflet.markercluster/index.d.ts b/types/leaflet.markercluster/index.d.ts
index b6780ec357..f60a7a2891 100644
--- a/types/leaflet.markercluster/index.d.ts
+++ b/types/leaflet.markercluster/index.d.ts
@@ -2,12 +2,11 @@
 // Project: https://github.com/Leaflet/Leaflet.markercluster
 // Definitions by: Robert Imig <https://github.com/rimig>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-import * as Leaflet from "leaflet";
+import * as L from 'leaflet';
 
-export = Leaflet;
-
-declare global { namespace L {
+declare module 'leaflet' {
     interface MarkerCluster extends Marker {
         /*
         * Recursively retrieve all child markers of this cluster.
@@ -166,4 +165,4 @@ declare global { namespace L {
     * Create a marker cluster group, optionally given marker cluster group options.
     */
     function markerClusterGroup(options?: MarkerClusterGroupOptions): MarkerClusterGroup;
-} }
+}
diff --git a/types/leaflet.markercluster/leaflet.markercluster-tests.ts b/types/leaflet.markercluster/leaflet.markercluster-tests.ts
index 2a2a4969e1..aeee213ca5 100644
--- a/types/leaflet.markercluster/leaflet.markercluster-tests.ts
+++ b/types/leaflet.markercluster/leaflet.markercluster-tests.ts
@@ -1,4 +1,5 @@
-import L = require("leaflet.markercluster");
+import * as L from 'leaflet';
+import 'leaflet.markercluster';
 
 const polylineOptions: L.PolylineOptions = {};
 const icon: L.Icon = L.icon({ iconUrl: 'foo' });
diff --git a/types/leaflet.pm/index.d.ts b/types/leaflet.pm/index.d.ts
index 4f3065b489..e33d335a7b 100644
--- a/types/leaflet.pm/index.d.ts
+++ b/types/leaflet.pm/index.d.ts
@@ -2,10 +2,11 @@
 // Project: https://github.com/codeofsumit/leaflet.pm
 // Definitions by: Thomas Kleinke <https://github.com/tkleinke>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-/// <reference types="leaflet" />
+import * as L from 'leaflet';
 
-declare namespace L {
+declare module 'leaflet' {
     interface Map {
         pm: PM.Map;
     }
diff --git a/types/leaflet.pm/leaflet.pm-tests.ts b/types/leaflet.pm/leaflet.pm-tests.ts
index 98b35a465f..f9cf58c308 100644
--- a/types/leaflet.pm/leaflet.pm-tests.ts
+++ b/types/leaflet.pm/leaflet.pm-tests.ts
@@ -1,3 +1,6 @@
+import * as L from 'leaflet';
+import 'leaflet-pm';
+
 const toolbarOptions: L.PM.ToolbarOptions = {
     position: 'topleft',
     drawMarker: true,
diff --git a/types/leaflet/index.d.ts b/types/leaflet/index.d.ts
index a5a0cf112c..aa0a0e2e92 100644
--- a/types/leaflet/index.d.ts
+++ b/types/leaflet/index.d.ts
@@ -1,1556 +1,1525 @@
-// Type definitions for Leaflet.js 1.0
+// Type definitions for Leaflet.js 1.2
 // Project: https://github.com/Leaflet/Leaflet
 // Definitions by: Alejandro Sánchez <https://github.com/alejo90>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-/// <reference types="geojson" />
+export as namespace L;
 
-type NativeMouseEvent = MouseEvent;
-type NativeKeyboardEvent = KeyboardEvent;
+import * as geojson from 'geojson';
 
-// Import to avoid conflicts with the GeoJSON class of leaflet
-import GeoJSONFeature = GeoJSON.Feature;
-import GeoJSONLineString = GeoJSON.LineString;
-import GeoJSONMultiLineString = GeoJSON.MultiLineString;
-import GeoJSONPolygon = GeoJSON.Polygon;
-import GeoJSONMultiPolygon = GeoJSON.MultiPolygon;
-import GeoJSONFeatureCollection = GeoJSON.FeatureCollection;
-import GeoJSONGeometryObject = GeoJSON.GeometryObject;
-import GeoJSONGeometryCollection = GeoJSON.GeometryCollection;
-import GeoJSONPoint = GeoJSON.Point;
-import GeoJSONMultiPoint = GeoJSON.MultiPoint;
-import GeoJSONGeoJsonObject = GeoJSON.GeoJsonObject;
+export class Class {
+    static extend(props: any): any/* how to return constructor of self extended type ? */;
+    static include(props: any): any /* how to return self extended type ? */;
+    static mergeOptions(props: any): any /* how to return self extended type ? */;
+    static addInitHook(initHookFn: () => void): any/* how to return self extended type ? */;
+}
 
-declare namespace L {
-    class Class {
-        static extend(props: any): any/* how to return constructor of self extended type ? */;
-        static include(props: any): any /* how to return self extended type ? */;
-        static mergeOptions(props: any): any /* how to return self extended type ? */;
-        static addInitHook(initHookFn: () => void): any/* how to return self extended type ? */;
+export class Transformation {
+    constructor(a: number, b: number, c: number, d: number);
+
+    transform(point: Point, scale?: number): Point;
+
+    untransform(point: Point, scale?: number): Point;
+}
+
+export namespace LineUtil {
+    function simplify(points: Point[], tolerance: number): Point[];
+
+    function pointToSegmentDistance(p: Point, p1: Point, p2: Point): number;
+
+    function closestPointOnSegment(p: Point, p1: Point, p2: Point): Point;
+}
+
+export namespace PolyUtil {
+    function clipPolygon(points: Point[], bounds: BoundsExpression, round?: boolean): Point[];
+}
+
+export namespace DomUtil {
+    /**
+     * Get Element by its ID or with the given HTML-Element
+     */
+    function get(element: string | HTMLElement): HTMLElement | null;
+    function getStyle(el: HTMLElement, styleAttrib: string): string | null;
+    function create(tagName: string, className?: string, container?: HTMLElement): HTMLElement;
+    function remove(el: HTMLElement): void;
+    function empty(el: HTMLElement): void;
+    function toFront(el: HTMLElement): void;
+    function toBack(el: HTMLElement): void;
+    function hasClass(el: HTMLElement, name: string): boolean;
+    function addClass(el: HTMLElement, name: string): void;
+    function removeClass(el: HTMLElement, name: string): void;
+    function setClass(el: HTMLElement, name: string): void;
+    function getClass(el: HTMLElement): string;
+    function setOpacity(el: HTMLElement, opacity: number): void;
+    function testProp(props: string[]): string | false;
+    function setTransform(el: HTMLElement, offset: Point, scale?: number): void;
+    function setPosition(el: HTMLElement, position: Point): void;
+    function getPosition(el: HTMLElement): Point;
+    function disableTextSelection(): void;
+    function enableTextSelection(): void;
+    function disableImageDrag(): void;
+    function enableImageDrag(): void;
+    function preventOutline(el: HTMLElement): void;
+    function restoreOutline(): void;
+
+    let TRANSFORM: string;
+    let TRANSITION: string;
+    let TRANSITION_END: string;
+}
+
+export interface CRS {
+    latLngToPoint(latlng: LatLngExpression, zoom: number): Point;
+    pointToLatLng(point: PointExpression, zoom: number): LatLng;
+    project(latlng: LatLng | LatLngLiteral): Point;
+    unproject(point: PointExpression): LatLng;
+    scale(zoom: number): number;
+    zoom(scale: number): number;
+    getProjectedBounds(zoom: number): Bounds;
+    distance(latlng1: LatLngExpression, latlng2: LatLngExpression): number;
+    wrapLatLng(latlng: LatLng | LatLngLiteral): LatLng;
+
+    code?: string;
+    wrapLng?: [number, number];
+    wrapLat?: [number, number];
+    infinite: boolean;
+}
+
+export namespace CRS {
+    const EPSG3395: CRS;
+    const EPSG3857: CRS;
+    const EPSG4326: CRS;
+    const Earth: CRS;
+    const Simple: CRS;
+}
+
+export interface Projection {
+    project(latlng: LatLng | LatLngLiteral): Point;
+    unproject(point: PointExpression): LatLng;
+
+    bounds: Bounds;
+}
+
+export namespace Projection {
+    const LonLat: Projection;
+    const Mercator: Projection;
+    const SphericalMercator: Projection;
+}
+
+export class LatLng {
+    constructor(latitude: number, longitude: number, altitude?: number);
+    equals(otherLatLng: LatLngExpression, maxMargin?: number): boolean;
+    toString(): string;
+    distanceTo(otherLatLng: LatLngExpression): number;
+    wrap(): LatLng;
+    toBounds(sizeInMeters: number): LatLngBounds;
+
+    lat: number;
+    lng: number;
+    alt?: number;
+}
+
+export interface LatLngLiteral {
+    lat: number;
+    lng: number;
+}
+
+export type LatLngTuple = [number, number];
+
+export type LatLngExpression = LatLng | LatLngLiteral | LatLngTuple;
+
+export function latLng(latitude: number, longitude: number, altitude?: number): LatLng;
+
+export function latLng(coords: LatLngTuple | [number, number, number] | LatLngLiteral | {lat: number, lng: number, alt?: number}): LatLng;
+
+export class LatLngBounds {
+    constructor(southWest: LatLngExpression, northEast: LatLngExpression);
+    constructor(latlngs: LatLngBoundsLiteral);
+    extend(latlngOrBounds: LatLngExpression | LatLngBoundsExpression): this;
+    pad(bufferRatio: number): LatLngBounds; // does this modify the current instance or does it return a new one?
+    getCenter(): LatLng;
+    getSouthWest(): LatLng;
+    getNorthEast(): LatLng;
+    getNorthWest(): LatLng;
+    getSouthEast(): LatLng;
+    getWest(): number;
+    getSouth(): number;
+    getEast(): number;
+    getNorth(): number;
+    contains(otherBoundsOrLatLng: LatLngBoundsExpression | LatLngExpression): boolean;
+    intersects(otherBounds: LatLngBoundsExpression): boolean;
+    overlaps(otherBounds: BoundsExpression): boolean; // investigate if this is really bounds and not latlngbounds
+    toBBoxString(): string;
+    equals(otherBounds: LatLngBoundsExpression): boolean;
+    isValid(): boolean;
+}
+
+export type LatLngBoundsLiteral = LatLngTuple[]; // Must be [LatLngTuple, LatLngTuple], cant't change because Map.setMaxBounds
+
+export type LatLngBoundsExpression = LatLngBounds | LatLngBoundsLiteral;
+
+export function latLngBounds(southWest: LatLngExpression, northEast: LatLngExpression): LatLngBounds;
+
+export function latLngBounds(latlngs: LatLngExpression[]): LatLngBounds;
+
+export type PointTuple = [number, number];
+
+export class Point {
+    constructor(x: number, y: number, round?: boolean);
+    clone(): Point;
+    add(otherPoint: PointExpression): Point; // non-destructive, returns a new point
+    subtract(otherPoint: PointExpression): Point;
+    divideBy(num: number): Point;
+    multiplyBy(num: number): Point;
+    scaleBy(scale: PointExpression): Point;
+    unscaleBy(scale: PointExpression): Point;
+    round(): Point;
+    floor(): Point;
+    ceil(): Point;
+    distanceTo(otherPoint: PointExpression): number;
+    equals(otherPoint: PointExpression): boolean;
+    contains(otherPoint: PointExpression): boolean;
+    toString(): string;
+    x: number;
+    y: number;
+}
+
+export type PointExpression = Point | PointTuple;
+
+export function point(x: number, y: number, round?: boolean): Point;
+
+export function point(coords: PointTuple | {x: number, y: number}): Point;
+
+export type BoundsLiteral = [PointTuple, PointTuple];
+
+export class Bounds {
+    constructor(topLeft: PointExpression, bottomRight: PointExpression);
+    constructor(points: Point[] | BoundsLiteral);
+    extend(point: PointExpression): this;
+    getCenter(round?: boolean): Point;
+    getBottomLeft(): Point;
+    getTopRight(): Point;
+    getSize(): Point;
+    contains(pointOrBounds: BoundsExpression | PointExpression): boolean;
+    intersects(otherBounds: BoundsExpression): boolean;
+    overlaps(otherBounds: BoundsExpression): boolean;
+
+    min?: Point;
+    max?: Point;
+}
+
+export type BoundsExpression = Bounds | BoundsLiteral;
+
+export function bounds(topLeft: PointExpression, bottomRight: PointExpression): Bounds;
+
+export function bounds(points: Point[] | BoundsLiteral): Bounds;
+
+export type LeafletEventHandlerFn = (event: LeafletEvent) => void;
+
+export interface LeafletEventHandlerFnMap {
+    [type: string]: LeafletEventHandlerFn;
+}
+
+/**
+ * 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).
+ */
+export abstract class Evented extends Class {
+    /**
+     * 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').
+     */
+    on(type: string, fn: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove}
+     */
+    on(eventMap: LeafletEventHandlerFnMap): this;
+
+    /* tslint:disable:unified-signatures */ // With an eventMap there are no additional arguments allowed
+    /**
+     * 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.
+     */
+    off(type: string, fn?: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Removes a set of type/listener pairs.
+     */
+    off(eventMap: LeafletEventHandlerFnMap): this;
+    /* tslint:enable */
+    /**
+     * Removes all listeners to all events on the object.
+     */
+    off(): 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.
+     */
+    fire(type: string, data?: any, propagate?: boolean): this;
+
+    /**
+     * Returns true if a particular event type has any listeners attached to it.
+     */
+    listens(type: string): boolean;
+
+    /**
+     * Behaves as on(...), except the listener will only get fired once and then removed.
+     */
+    once(type: string, fn: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Behaves as on(...), except the listener will only get fired once and then removed.
+     */
+    once(eventMap: LeafletEventHandlerFnMap): this;
+
+    /**
+     * Adds an event parent - an Evented that will receive propagated events
+     */
+    addEventParent(obj: Evented): this;
+
+    /**
+     * Removes an event parent, so it will stop receiving propagated events
+     */
+    removeEventParent(obj: Evented): 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').
+     */
+    addEventListener(type: string, fn: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Alias for on(...)
+     *
+     * Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove}
+     */
+    addEventListener(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.
+     */
+    removeEventListener(type: string, fn: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Alias for off(...)
+     *
+     * Removes a set of type/listener pairs.
+     */
+    removeEventListener(eventMap: LeafletEventHandlerFnMap): this;
+
+    /**
+     * Alias for off()
+     *
+     * Removes all listeners to all events on the object.
+     */
+    clearAllEventListeners(): this;
+
+    /**
+     * Alias for once(...)
+     *
+     * Behaves as on(...), except the listener will only get fired once and then removed.
+     */
+    addOneTimeEventListener(type: string, fn: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Alias for once(...)
+     *
+     * Behaves as on(...), except the listener will only get fired once and then removed.
+     */
+    addOneTimeEventListener(eventMap: LeafletEventHandlerFnMap): 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.
+     */
+    fireEvent(type: string, data?: any, propagate?: boolean): this;
+
+    /**
+     * Alias for listens(...)
+     *
+     * Returns true if a particular event type has any listeners attached to it.
+     */
+    hasEventListeners(type: string): boolean;
+}
+
+/**
+ * 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).
+ */
+export class Draggable extends Evented {
+    constructor(element: HTMLElement, dragStartTarget?: HTMLElement, preventOutline?: boolean);
+
+    enable(): void;
+
+    disable(): void;
+
+    finishDrag(): void;
+}
+
+export interface LayerOptions {
+    pane?: string;
+    attribution?: string;
+}
+
+export interface InteractiveLayerOptions extends LayerOptions {
+    interactive?: boolean;
+}
+
+export class Layer extends Evented {
+    constructor(options?: LayerOptions);
+    addTo(map: Map|LayerGroup): this;
+    remove(): this;
+    removeFrom(map: Map): this;
+    getPane(name?: string): HTMLElement | undefined;
+
+    // Popup methods
+    bindPopup(content: ((layer: Layer) => Content) | Content | Popup, options?: PopupOptions): this;
+    unbindPopup(): this;
+    openPopup(latlng?: LatLngExpression): this;
+    closePopup(): this;
+    togglePopup(): this;
+    isPopupOpen(): boolean;
+    setPopupContent(content: Content | Popup): this;
+    getPopup(): Popup | undefined;
+
+    // Tooltip methods
+    bindTooltip(content: ((layer: Layer) => Content) | Tooltip | Content, options?: TooltipOptions): this;
+    unbindTooltip(): this;
+    openTooltip(latlng?: LatLngExpression): this;
+    closeTooltip(): this;
+    toggleTooltip(): this;
+    isTooltipOpen(): boolean;
+    setTooltipContent(content: Content | Tooltip): this;
+    getTooltip(): Tooltip | undefined;
+
+    // Extension methods
+    onAdd(map: Map): this;
+    onRemove(map: Map): this;
+    getEvents?(): {[name: string]: (event: LeafletEvent) => void};
+    getAttribution?(): string | null;
+    beforeAdd?(map: Map): this;
+}
+
+export interface GridLayerOptions {
+    tileSize?: number | Point;
+    opacity?: number;
+    updateWhenIdle?: boolean;
+    updateWhenZooming?: boolean;
+    updateInterval?: number;
+    attribution?: string;
+    zIndex?: number;
+    bounds?: LatLngBoundsExpression;
+    minZoom?: number;
+    maxZoom?: number;
+    noWrap?: boolean;
+    pane?: string;
+    className?: string;
+    keepBuffer?: number;
+}
+
+export class GridLayer extends Layer {
+    constructor(options?: GridLayerOptions);
+    bringToFront(): this;
+    bringToBack(): this;
+    getContainer(): HTMLElement | null;
+    setOpacity(opacity: number): this;
+    setZIndex(zIndex: number): this;
+    isLoading(): boolean;
+    redraw(): this;
+    getTileSize(): Point;
+}
+
+export function gridLayer(options?: GridLayerOptions): GridLayer;
+
+export interface TileLayerOptions extends GridLayerOptions {
+    minZoom?: number;
+    maxZoom?: number;
+    maxNativeZoom?: number;
+    minNativeZoom?: number;
+    subdomains?: string | string[];
+    errorTileUrl?: string;
+    zoomOffset?: number;
+    tms?: boolean;
+    zoomReverse?: boolean;
+    detectRetina?: boolean;
+    crossOrigin?: boolean;
+    [name: string]: any;
+}
+
+export class TileLayer extends GridLayer {
+    constructor(urlTemplate: string, options?: TileLayerOptions);
+    setUrl(url: string, noRedraw?: boolean): this;
+
+    options: TileLayerOptions;
+}
+
+export function tileLayer(urlTemplate: string, options?: TileLayerOptions): TileLayer;
+
+export namespace TileLayer {
+    class WMS extends TileLayer {
+        constructor(baseUrl: string, options: WMSOptions);
+        setParams(params: WMSParams, noRedraw?: boolean): this;
+
+        wmsParams: WMSParams;
+        options: WMSOptions;
+    }
+}
+
+export interface WMSOptions extends TileLayerOptions {
+    layers?: string;
+    styles?: string;
+    format?: string;
+    transparent?: boolean;
+    version?: string;
+    crs?: CRS;
+    uppercase?: boolean;
+}
+
+export interface WMSParams {
+    format?: string;
+    layers: string;
+    request?: string;
+    service?: string;
+    styles?: string;
+    version?: string;
+    transparent?: boolean;
+    width?: number;
+    height?: number;
+}
+
+export namespace tileLayer {
+    function wms(baseUrl: string, options?: WMSOptions): TileLayer.WMS;
+}
+
+export interface ImageOverlayOptions extends LayerOptions {
+    opacity?: number;
+    alt?: string;
+    interactive?: boolean;
+    attribution?: string;
+    crossOrigin?: boolean;
+}
+
+export class ImageOverlay extends Layer {
+    constructor(imageUrl: string, bounds: LatLngBoundsExpression, options?: ImageOverlayOptions);
+    setOpacity(opacity: number): this;
+    bringToFront(): this;
+    bringToBack(): this;
+    setUrl(url: string): this;
+
+    /** Update the bounds that this ImageOverlay covers */
+    setBounds(bounds: LatLngBounds): this;
+
+    /** Get the bounds that this ImageOverlay covers */
+    getBounds(): LatLngBounds;
+
+    /** Get the img element that represents the ImageOverlay on the map */
+    getElement(): HTMLImageElement | undefined;
+
+    options: ImageOverlayOptions;
+}
+
+export function imageOverlay(imageUrl: string, bounds: LatLngBoundsExpression, options?: ImageOverlayOptions): ImageOverlay;
+
+export type LineCapShape = 'butt' | 'round' | 'square' | 'inherit';
+
+export type LineJoinShape = 'miter' | 'round' | 'bevel' | 'inherit';
+
+export type FillRule = 'nonzero' | 'evenodd' | 'inherit';
+
+export interface PathOptions extends InteractiveLayerOptions {
+    stroke?: boolean;
+    color?: string;
+    weight?: number;
+    opacity?: number;
+    lineCap?: LineCapShape;
+    lineJoin?: LineJoinShape;
+    dashArray?: string;
+    dashOffset?: string;
+    fill?: boolean;
+    fillColor?: string;
+    fillOpacity?: number;
+    fillRule?: FillRule;
+    renderer?: Renderer;
+    className?: string;
+}
+
+export abstract class Path extends Layer {
+    redraw(): this;
+    setStyle(style: PathOptions): this;
+    bringToFront(): this;
+    bringToBack(): this;
+    getElement(): Element | undefined;
+
+    options: PathOptions;
+}
+
+export interface PolylineOptions extends PathOptions {
+    smoothFactor?: number;
+    noClip?: boolean;
+}
+
+export class Polyline<T extends geojson.GeometryObject = geojson.LineString | geojson.MultiLineString> extends Path {
+    constructor(latlngs: LatLngExpression[], options?: PolylineOptions);
+    toGeoJSON(): geojson.Feature<T>;
+    getLatLngs(): LatLng[];
+    setLatLngs(latlngs: LatLngExpression[]): this;
+    isEmpty(): boolean;
+    getCenter(): LatLng;
+    getBounds(): LatLngBounds;
+    addLatLng(latlng: LatLngExpression | LatLngExpression[]): this;
+
+    feature?: geojson.Feature<T>;
+    options: PolylineOptions;
+}
+
+export function polyline(latlngs: LatLngExpression[], options?: PolylineOptions): Polyline;
+
+export class Polygon extends Polyline<geojson.Polygon | geojson.MultiPolygon> {
+    constructor(latlngs: LatLngExpression[] | LatLngExpression[][], options?: PolylineOptions);
+}
+
+export function polygon(latlngs: LatLngExpression[] | LatLngExpression[][], options?: PolylineOptions): Polygon;
+
+export class Rectangle extends Polygon {
+    constructor(latLngBounds: LatLngBoundsExpression, options?: PolylineOptions);
+    setBounds(latLngBounds: LatLngBoundsExpression): this;
+}
+
+export function rectangle(latLngBounds: LatLngBoundsExpression, options?: PolylineOptions): Rectangle;
+
+export interface CircleMarkerOptions extends PathOptions {
+    radius?: number;
+}
+
+export class CircleMarker extends Path {
+    constructor(latlng: LatLngExpression, options?: CircleMarkerOptions);
+    toGeoJSON(): geojson.Feature<geojson.Point>;
+    setLatLng(latLng: LatLngExpression): this;
+    getLatLng(): LatLng;
+    setRadius(radius: number): this;
+    getRadius(): number;
+
+    options: CircleMarkerOptions;
+    feature?: geojson.Feature<geojson.Point>;
+}
+
+export function circleMarker(latlng: LatLngExpression, options?: CircleMarkerOptions): CircleMarker;
+
+export class Circle extends CircleMarker {
+    constructor(latlng: LatLngExpression, options?: CircleMarkerOptions);
+    constructor(latlng: LatLngExpression, radius: number, options?: CircleMarkerOptions); // deprecated!
+    getBounds(): LatLngBounds;
+}
+
+export function circle(latlng: LatLngExpression, options?: CircleMarkerOptions): Circle;
+export function circle(latlng: LatLngExpression, radius: number, options?: CircleMarkerOptions): Circle; // deprecated!
+
+export interface RendererOptions extends LayerOptions {
+    padding?: number;
+}
+
+export class Renderer extends Layer {
+    constructor(options?: RendererOptions);
+
+    options: RendererOptions;
+}
+
+export class SVG extends Renderer {}
+
+export namespace SVG {
+    function create(name: string): SVGElement;
+
+    function pointsToPath(rings: PointExpression[], close: boolean): string;
+}
+
+export function svg(options?: RendererOptions): SVG;
+
+export class Canvas extends Renderer {}
+
+export function canvas(options?: RendererOptions): Canvas;
+
+/**
+ * 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.
+ */
+export class LayerGroup extends Layer {
+    constructor(layers?: Layer[]);
+    /**
+     * Returns a GeoJSON representation of the layer group (as a GeoJSON GeometryCollection, GeoJSONFeatureCollection or Multipoint).
+     */
+    toGeoJSON(): geojson.FeatureCollection<geojson.GeometryObject> | geojson.Feature<geojson.MultiPoint> | geojson.GeometryCollection;
+
+    /**
+     * Adds the given layer to the group.
+     */
+    addLayer(layer: Layer): this;
+
+    /**
+     * Removes the layer with the given internal ID or the given layer from the group.
+     */
+    removeLayer(layer: number | Layer): this;
+
+    /**
+     * Returns true if the given layer is currently added to the group.
+     */
+    hasLayer(layer: Layer): boolean;
+
+    /**
+     * Removes all the layers from the group.
+     */
+    clearLayers(): 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.
+     */
+    invoke(methodName: string, ...params: any[]): this;
+
+    /**
+     * Iterates over the layers of the group,
+     * optionally specifying context of the iterator function.
+     */
+    eachLayer(fn: (layer: Layer) => void, context?: any): this;
+
+    /**
+     * Returns the layer with the given internal ID.
+     */
+    getLayer(id: number): Layer | undefined;
+
+    /**
+     * Returns an array of all the layers added to the group.
+     */
+    getLayers(): Layer[];
+
+    /**
+     * Calls setZIndex on every layer contained in this group, passing the z-index.
+     */
+    setZIndex(zIndex: number): this;
+
+    /**
+     * Returns the internal ID for a layer
+     */
+    getLayerId(layer: Layer): number;
+
+    feature?: geojson.FeatureCollection<geojson.GeometryObject> | geojson.Feature<geojson.MultiPoint> | geojson.GeometryCollection;
+}
+
+/**
+ * Create a layer group, optionally given an initial set of layers.
+ */
+export function layerGroup(layers: Layer[]): LayerGroup;
+
+/**
+ * Extended LayerGroup that also has mouse events (propagated from
+ * members of the group) and a shared bindPopup method.
+ */
+export class FeatureGroup extends LayerGroup {
+    /**
+     * Sets the given path options to each layer of the group that has a setStyle method.
+     */
+    setStyle(style: StyleFunction): this;
+
+    /**
+     * Brings the layer group to the top of all other layers
+     */
+    bringToFront(): this;
+
+    /**
+     * Brings the layer group to the top [sic] of all other layers
+     */
+    bringToBack(): this;
+
+    /**
+     * Returns the LatLngBounds of the Feature Group (created from
+     * bounds and coordinates of its children).
+     */
+    getBounds(): LatLngBounds;
+}
+
+/**
+ * Create a feature group, optionally given an initial set of layers.
+ */
+export function featureGroup(layers?: Layer[]): FeatureGroup;
+
+export type StyleFunction = (feature?: geojson.Feature<geojson.GeometryObject>) => PathOptions;
+
+export interface GeoJSONOptions extends LayerOptions {
+    /**
+     * A Function defining how GeoJSON points spawn Leaflet layers.
+     * It is internally called when data is added, passing the GeoJSON point
+     * feature and its LatLng.
+     *
+     * The default is to spawn a default Marker:
+     *
+     * ```
+     * function(geoJsonPoint, latlng) {
+     *     return L.marker(latlng);
+     * }
+     * ```
+     */
+    pointToLayer?(geoJsonPoint: geojson.Feature<geojson.Point>, latlng: LatLng): Layer; // should import GeoJSON typings
+
+    /**
+     * A Function defining the Path options for styling GeoJSON lines and polygons,
+     * called internally when data is added.
+     *
+     * The default value is to not override any defaults:
+     *
+     * ```
+     * function (geoJsonFeature) {
+     *     return {}
+     * }
+     * ```
+     */
+    style?: StyleFunction;
+
+    /**
+     * A Function that will be called once for each created Feature, after it
+     * has been created and styled. Useful for attaching events and popups to features.
+     *
+     * The default is to do nothing with the newly created layers:
+     *
+     * ```
+     * function (feature, layer) {}
+     * ```
+     */
+    onEachFeature?(feature: geojson.Feature<geojson.GeometryObject>, layer: Layer): void;
+
+    /**
+     * A Function that will be used to decide whether to show a feature or not.
+     *
+     * The default is to show all features:
+     *
+     * ```
+     * function (geoJsonFeature) {
+     *     return true;
+     * }
+     * ```
+     */
+    filter?(geoJsonFeature: geojson.Feature<geojson.GeometryObject>): boolean;
+
+    /**
+     * A Function that will be used for converting GeoJSON coordinates to LatLngs.
+     * The default is the coordsToLatLng static method.
+     */
+    coordsToLatLng?(coords: [number, number] | [number, number, number]): LatLng; // check if LatLng has an altitude property
+}
+
+/**
+ * Represents a GeoJSON object or an array of GeoJSON objects.
+ * Allows you to parse GeoJSON data and display it on the map. Extends FeatureGroup.
+ */
+export class GeoJSON extends FeatureGroup {
+    /**
+     * Creates a Layer from a given GeoJSON feature. Can use a custom pointToLayer
+     * and/or coordsToLatLng functions if provided as options.
+     */
+    static geometryToLayer(featureData: geojson.Feature<geojson.GeometryObject>, options?: GeoJSONOptions): Layer;
+
+    /**
+     * Creates a LatLng object from an array of 2 numbers (longitude, latitude) or
+     * 3 numbers (longitude, latitude, altitude) used in GeoJSON for points.
+     */
+    static coordsToLatLng(coords: [number, number] | [number, number, number]): LatLng;
+
+    /**
+     * 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.
+     */
+    static coordsToLatLngs(
+        coords: any[],
+        levelsDeep?: number,
+        coordsToLatLng?: (coords: [number, number] | [number, number, number]) => LatLng): any[]; // Using any[] to avoid artificially limiting valid calls
+
+    /**
+     * Reverse of coordsToLatLng
+     */
+    static latLngToCoords(latlng: LatLng): [number, number] | [number, number, number];
+
+    /**
+     * 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.
+     */
+    static latLngsToCoords(latlngs: any[], levelsDeep?: number, closed?: boolean): any[];  // Using any[] to avoid artificially limiting valid calls
+
+    /**
+     * Normalize GeoJSON geometries/features into GeoJSON features.
+     */
+    static asFeature(geojson: geojson.Feature<geojson.GeometryObject> | geojson.GeometryObject): geojson.Feature<geojson.GeometryObject>;
+
+    constructor(geojson?: geojson.GeoJsonObject, options?: GeoJSONOptions)
+    /**
+     * Adds a GeoJSON object to the layer.
+     */
+    addData(data: geojson.GeoJsonObject): Layer;
+
+    /**
+     * Resets the given vector layer's style to the original GeoJSON style,
+     * useful for resetting style after hover events.
+     */
+    resetStyle(layer: Layer): Layer;
+
+    /**
+     * Changes styles of GeoJSON vector layers with the given style function.
+     */
+    setStyle(style: StyleFunction): this;
+
+    options: GeoJSONOptions;
+}
+
+/**
+ * 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.
+ */
+export function geoJSON(geojson?: geojson.GeoJsonObject, options?: GeoJSONOptions): GeoJSON;
+
+export type Zoom = boolean | 'center';
+
+export interface MapOptions {
+    preferCanvas?: boolean;
+
+    // Control options
+    attributionControl?: boolean;
+    zoomControl?: boolean;
+
+    // Interaction options
+    closePopupOnClick?: boolean;
+    zoomSnap?: number;
+    zoomDelta?: number;
+    trackResize?: boolean;
+    boxZoom?: boolean;
+    doubleClickZoom?: Zoom;
+    dragging?: boolean;
+
+    // Map state options
+    crs?: CRS;
+    center?: LatLngExpression;
+    zoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    layers?: Layer[];
+    maxBounds?: LatLngBoundsExpression;
+    renderer?: Renderer;
+
+    // Animation options
+    fadeAnimation?: boolean;
+    markerZoomAnimation?: boolean;
+    transform3DLimit?: number;
+    zoomAnimation?: boolean;
+    zoomAnimationThreshold?: number;
+
+    // Panning inertia options
+    inertia?: boolean;
+    inertiaDeceleration?: number;
+    inertiaMaxSpeed?: number;
+    easeLinearity?: number;
+    worldCopyJump?: boolean;
+    maxBoundsViscosity?: number;
+
+    // Keyboard navigation options
+    keyboard?: boolean;
+    keyboardPanDelta?: number;
+
+    // Mousewheel options
+    scrollWheelZoom?: Zoom;
+    wheelDebounceTime?: number;
+    wheelPxPerZoomLevel?: number;
+
+    // Touch interaction options
+    tap?: boolean;
+    tapTolerance?: number;
+    touchZoom?: Zoom;
+    bounceAtZoomLimits?: boolean;
+}
+
+export type ControlPosition = 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
+
+export interface ControlOptions {
+    position?: ControlPosition;
+}
+
+export class Control extends Class {
+    constructor(options?: ControlOptions);
+    getPosition(): ControlPosition;
+    setPosition(position: ControlPosition): this;
+    getContainer(): HTMLElement | undefined;
+    addTo(map: Map): this;
+    remove(): this;
+
+    // Extension methods
+    onAdd?(map: Map): HTMLElement;
+    onRemove?(map: Map): void;
+
+    options: ControlOptions;
+}
+
+export namespace Control {
+    interface ZoomOptions extends ControlOptions {
+        zoomInText?: string;
+        zoomInTitle?: string;
+        zoomOutText?: string;
+        zoomOutTitle?: string;
     }
 
-    class Transformation {
-        constructor(a: number, b: number, c: number, d: number);
-
-        transform(point: Point, scale?: number): Point;
-
-        untransform(point: Point, scale?: number): Point;
+    class Zoom extends Control {
+        constructor(options?: ZoomOptions);
+        options: ZoomOptions;
     }
 
-    namespace LineUtil {
-        function simplify(points: Point[], tolerance: number): Point[];
-
-        function pointToSegmentDistance(p: Point, p1: Point, p2: Point): number;
-
-        function closestPointOnSegment(p: Point, p1: Point, p2: Point): Point;
+    interface AttributionOptions extends ControlOptions {
+        prefix?: string | boolean;
     }
 
-    namespace PolyUtil {
-        function clipPolygon(points: Point[], bounds: BoundsExpression, round?: boolean): Point[];
+    class Attribution extends Control {
+        constructor(options?: AttributionOptions);
+        setPrefix(prefix: string): this;
+        addAttribution(text: string): this;
+        removeAttribution(text: string): this;
+        options: AttributionOptions;
     }
 
-    namespace DomUtil {
-        /**
-         * Get Element by its ID or with the given HTML-Element
-         */
-        function get(element: string | HTMLElement): HTMLElement | null;
-        function getStyle(el: HTMLElement, styleAttrib: string): string | null;
-        function create(tagName: string, className?: string, container?: HTMLElement): HTMLElement;
-        function remove(el: HTMLElement): void;
-        function empty(el: HTMLElement): void;
-        function toFront(el: HTMLElement): void;
-        function toBack(el: HTMLElement): void;
-        function hasClass(el: HTMLElement, name: string): boolean;
-        function addClass(el: HTMLElement, name: string): void;
-        function removeClass(el: HTMLElement, name: string): void;
-        function setClass(el: HTMLElement, name: string): void;
-        function getClass(el: HTMLElement): string;
-        function setOpacity(el: HTMLElement, opacity: number): void;
-        function testProp(props: string[]): string | false;
-        function setTransform(el: HTMLElement, offset: Point, scale?: number): void;
-        function setPosition(el: HTMLElement, position: Point): void;
-        function getPosition(el: HTMLElement): Point;
-        function disableTextSelection(): void;
-        function enableTextSelection(): void;
-        function disableImageDrag(): void;
-        function enableImageDrag(): void;
-        function preventOutline(el: HTMLElement): void;
-        function restoreOutline(): void;
-
-        let TRANSFORM: string;
-        let TRANSITION: string;
-        let TRANSITION_END: string;
+    interface LayersOptions extends ControlOptions {
+        collapsed?: boolean;
+        autoZIndex?: boolean;
+        hideSingleBase?: boolean;
     }
 
-    interface CRS {
-        latLngToPoint(latlng: LatLngExpression, zoom: number): Point;
-        pointToLatLng(point: PointExpression, zoom: number): LatLng;
-        project(latlng: LatLng | LatLngLiteral): Point;
-        unproject(point: PointExpression): LatLng;
-        scale(zoom: number): number;
-        zoom(scale: number): number;
-        getProjectedBounds(zoom: number): Bounds;
-        distance(latlng1: LatLngExpression, latlng2: LatLngExpression): number;
-        wrapLatLng(latlng: LatLng | LatLngLiteral): LatLng;
-
-        code?: string;
-        wrapLng?: [number, number];
-        wrapLat?: [number, number];
-        infinite: boolean;
+    interface LayersObject {
+        [name: string]: Layer;
     }
 
-    namespace CRS {
-        const EPSG3395: CRS;
-        const EPSG3857: CRS;
-        const EPSG4326: CRS;
-        const Earth: CRS;
-        const Simple: CRS;
+    class Layers extends Control {
+        constructor(baseLayers?: LayersObject, overlays?: LayersObject, options?: LayersOptions);
+        addBaseLayer(layer: Layer, name: string): this;
+        addOverlay(layer: Layer, name: string): this;
+        removeLayer(layer: Layer): this;
+        expand(): this;
+        collapse(): this;
+        options: LayersOptions;
     }
 
-    interface Projection {
-        project(latlng: LatLng | LatLngLiteral): Point;
-        unproject(point: PointExpression): LatLng;
-
-        bounds: Bounds;
+    interface ScaleOptions extends ControlOptions {
+        maxWidth?: number;
+        metric?: boolean;
+        imperial?: boolean;
+        updateWhenIdle?: boolean;
     }
 
-    namespace Projection {
-        const LonLat: Projection;
-        const Mercator: Projection;
-        const SphericalMercator: Projection;
+    class Scale extends Control {
+        constructor(options?: ScaleOptions);
+        options: ScaleOptions;
     }
+}
 
-    class LatLng {
-        constructor(latitude: number, longitude: number, altitude?: number);
-        equals(otherLatLng: LatLngExpression, maxMargin?: number): boolean;
-        toString(): string;
-        distanceTo(otherLatLng: LatLngExpression): number;
-        wrap(): LatLng;
-        toBounds(sizeInMeters: number): LatLngBounds;
+export namespace control {
+    function zoom(options?: Control.ZoomOptions): Control.Zoom;
 
-        lat: number;
-        lng: number;
-        alt?: number;
-    }
+    function attribution(options?: Control.AttributionOptions): Control.Attribution;
 
-    interface LatLngLiteral {
-        lat: number;
-        lng: number;
-    }
+    function layers(baseLayers?: Control.LayersObject, overlays?: Control.LayersObject, options?: Control.LayersOptions): Control.Layers;
 
-    type LatLngTuple = [number, number];
+    function scale(options?: Control.ScaleOptions): Control.Scale;
+}
 
-    type LatLngExpression = LatLng | LatLngLiteral | LatLngTuple;
+export interface DivOverlayOptions {
+    offset?: PointExpression;
+    zoomAnimation?: boolean;
+    className?: string;
+    pane?: string;
+}
 
-    function latLng(latitude: number, longitude: number, altitude?: number): LatLng;
+export interface PopupOptions extends DivOverlayOptions {
+    maxWidth?: number;
+    minWidth?: number;
+    maxHeight?: number;
+    autoPan?: boolean;
+    autoPanPaddingTopLeft?: PointExpression;
+    autoPanPaddingBottomRight?: PointExpression;
+    autoPanPadding?: PointExpression;
+    keepInView?: boolean;
+    closeButton?: boolean;
+    autoClose?: boolean;
+    closeOnClick?: boolean;
+}
 
-    function latLng(coords: LatLngTuple | [number, number, number] | LatLngLiteral | {lat: number, lng: number, alt?: number}): LatLng;
+export type Content = string | HTMLElement;
 
-    class LatLngBounds {
-        constructor(southWest: LatLngExpression, northEast: LatLngExpression);
-        constructor(latlngs: LatLngBoundsLiteral);
-        extend(latlngOrBounds: LatLngExpression | LatLngBoundsExpression): this;
-        pad(bufferRatio: number): LatLngBounds; // does this modify the current instance or does it return a new one?
-        getCenter(): LatLng;
-        getSouthWest(): LatLng;
-        getNorthEast(): LatLng;
-        getNorthWest(): LatLng;
-        getSouthEast(): LatLng;
-        getWest(): number;
-        getSouth(): number;
-        getEast(): number;
-        getNorth(): number;
-        contains(otherBoundsOrLatLng: LatLngBoundsExpression | LatLngExpression): boolean;
-        intersects(otherBounds: LatLngBoundsExpression): boolean;
-        overlaps(otherBounds: BoundsExpression): boolean; // investigate if this is really bounds and not latlngbounds
-        toBBoxString(): string;
-        equals(otherBounds: LatLngBoundsExpression): boolean;
-        isValid(): boolean;
-    }
+export class Popup extends Layer {
+    constructor(options?: PopupOptions, source?: Layer);
+    getLatLng(): LatLng | undefined;
+    setLatLng(latlng: LatLngExpression): this;
+    getContent(): Content | ((source: Layer) => Content) | undefined;
+    setContent(htmlContent: ((source: Layer) => Content) | Content): this;
+    getElement(): HTMLElement | undefined;
+    update(): void;
+    isOpen(): boolean;
+    bringToFront(): this;
+    bringToBack(): this;
+    openOn(map: Map): this;
 
-    type LatLngBoundsLiteral = LatLngTuple[]; // Must be [LatLngTuple, LatLngTuple], cant't change because Map.setMaxBounds
+    options: PopupOptions;
+}
 
-    type LatLngBoundsExpression = LatLngBounds | LatLngBoundsLiteral;
+export function popup(options?: PopupOptions, source?: Layer): Popup;
 
-    function latLngBounds(southWest: LatLngExpression, northEast: LatLngExpression): LatLngBounds;
+export type Direction = 'right' | 'left' | 'top' | 'bottom' | 'center' | 'auto';
 
-    function latLngBounds(latlngs: LatLngExpression[]): LatLngBounds;
+export interface TooltipOptions extends DivOverlayOptions {
+    pane?: string;
+    offset?: PointExpression;
+    direction?: Direction;
+    permanent?: boolean;
+    sticky?: boolean;
+    interactive?: boolean;
+    opacity?: number;
+}
 
-    type PointTuple = [number, number];
+export class Tooltip extends Layer {
+    constructor(options?: TooltipOptions, source?: Layer);
+    setOpacity(val: number): void;
+    getLatLng(): LatLng | undefined;
+    setLatLng(latlng: LatLngExpression): this;
+    getContent(): Content | undefined;
+    setContent(htmlContent: ((source: Layer) => Content) | Content): this;
+    getElement(): HTMLElement | undefined;
+    update(): void;
+    isOpen(): boolean;
+    bringToFront(): this;
+    bringToBack(): this;
 
-    class Point {
-        constructor(x: number, y: number, round?: boolean);
-        clone(): Point;
-        add(otherPoint: PointExpression): Point; // non-destructive, returns a new point
-        subtract(otherPoint: PointExpression): Point;
-        divideBy(num: number): Point;
-        multiplyBy(num: number): Point;
-        scaleBy(scale: PointExpression): Point;
-        unscaleBy(scale: PointExpression): Point;
-        round(): Point;
-        floor(): Point;
-        ceil(): Point;
-        distanceTo(otherPoint: PointExpression): number;
-        equals(otherPoint: PointExpression): boolean;
-        contains(otherPoint: PointExpression): boolean;
-        toString(): string;
-        x: number;
-        y: number;
-    }
+    options: TooltipOptions;
+}
 
-    type PointExpression = Point | PointTuple;
+export function tooltip(options?: TooltipOptions, source?: Layer): Tooltip;
 
-    function point(x: number, y: number, round?: boolean): Point;
+export interface ZoomOptions {
+    animate?: boolean;
+}
 
-    function point(coords: PointTuple | {x: number, y: number}): Point;
+export interface PanOptions {
+    animate?: boolean;
+    duration?: number;
+    easeLinearity?: number;
+    noMoveStart?: boolean;
+}
 
-    type BoundsLiteral = [PointTuple, PointTuple];
+/* tslint:disable:no-empty-interface */ // This is not empty, it extends two interfaces into one...
+export interface ZoomPanOptions extends ZoomOptions, PanOptions {}
+/* tslint:enable */
 
-    class Bounds {
-        constructor(topLeft: PointExpression, bottomRight: PointExpression);
-        constructor(points: Point[] | BoundsLiteral);
-        extend(point: PointExpression): this;
-        getCenter(round?: boolean): Point;
-        getBottomLeft(): Point;
-        getTopRight(): Point;
-        getSize(): Point;
-        contains(pointOrBounds: BoundsExpression | PointExpression): boolean;
-        intersects(otherBounds: BoundsExpression): boolean;
-        overlaps(otherBounds: BoundsExpression): boolean;
+export interface FitBoundsOptions extends ZoomOptions, PanOptions {
+    paddingTopLeft?: PointExpression;
+    paddingBottomRight?: PointExpression;
+    padding?: PointExpression;
+    maxZoom?: number;
+}
 
-        min?: Point;
-        max?: Point;
-    }
+export interface LocateOptions {
+    watch?: boolean;
+    setView?: boolean;
+    maxZoom?: number;
+    timeout?: number;
+    maximumAge?: number;
+    enableHighAccuracy?: boolean;
+}
 
-    type BoundsExpression = Bounds | BoundsLiteral;
+export class Handler extends Class {
+    constructor(map: Map);
+    enable(): this;
+    disable(): this;
+    enabled(): boolean;
 
-    function bounds(topLeft: PointExpression, bottomRight: PointExpression): Bounds;
+    // Extension methods
+    addHooks?(): void;
+    removeHooks?(): void;
+}
 
-    function bounds(points: Point[] | BoundsLiteral): Bounds;
+export interface LeafletEvent {
+    type: string;
+    target: any;
+}
 
+export interface LeafletMouseEvent extends LeafletEvent {
+    latlng: LatLng;
+    layerPoint: Point;
+    containerPoint: Point;
+    originalEvent: MouseEvent;
+}
+
+export interface LeafletKeyboardEvent extends LeafletEvent {
+    originalEvent: KeyboardEvent;
+}
+
+export interface LocationEvent extends LeafletEvent {
+    latlng: LatLng;
+    bounds: LatLngBounds;
+    accuracy: number;
+    altitude: number;
+    altitudeAccuracy: number;
+    heading: number;
+    speed: number;
+    timestamp: number;
+}
+
+export interface ErrorEvent extends LeafletEvent {
+    message: string;
+    code: number;
+}
+
+export interface LayerEvent extends LeafletEvent {
+    layer: Layer;
+}
+
+export interface LayersControlEvent extends LayerEvent {
+    name: string;
+}
+
+export interface TileEvent extends LeafletEvent {
+    tile: HTMLImageElement;
+    coords: Point; // apparently not a normal point, since docs say it has z (zoom)
+}
+
+export interface TileErrorEvent extends TileEvent {
+    error: Error;
+}
+
+export interface ResizeEvent extends LeafletEvent {
+    oldSize: Point;
+    newSize: Point;
+}
+
+export interface GeoJSONEvent extends LeafletEvent {
+    layer: Layer;
+    properties: any;
+    geometryType: string;
+    id: string;
+}
+
+export interface PopupEvent extends LeafletEvent {
+    popup: Popup;
+}
+
+export interface TooltipEvent extends LeafletEvent {
+    tooltip: Tooltip;
+}
+
+export interface DragEndEvent extends LeafletEvent {
+    distance: number;
+}
+
+export interface ZoomAnimEvent extends LeafletEvent {
+    center: LatLng;
+    zoom: number;
+    noUpdate: boolean;
+}
+
+export namespace DomEvent {
     type EventHandlerFn = (event: Event) => void;
 
-    interface EventHandlerFnMap {
-        [type: string]: EventHandlerFn;
-    }
+    function on(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
 
+    function on(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
+
+    function off(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
+
+    function off(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
+
+    function stopPropagation(ev: Event): typeof DomEvent;
+
+    function disableScrollPropagation(el: HTMLElement): typeof DomEvent;
+
+    function disableClickPropagation(el: HTMLElement): typeof DomEvent;
+
+    function preventDefault(ev: Event): typeof DomEvent;
+
+    function stop(ev: Event): typeof DomEvent;
+
+    function getMousePosition(ev: MouseEvent, container?: HTMLElement): Point;
+
+    function getWheelDelta(ev: Event): number;
+
+    function addListener(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
+
+    function addListener(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
+
+    function removeListener(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
+
+    function removeListener(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
+}
+
+export interface DefaultMapPanes {
+    mapPane: HTMLElement;
+    tilePane: HTMLElement;
+    overlayPane: HTMLElement;
+    shadowPane: HTMLElement;
+    markerPane: HTMLElement;
+    tooltipPane: HTMLElement;
+    popupPane: HTMLElement;
+}
+
+export class Map extends Evented {
+    constructor(element: string | HTMLElement, options?: MapOptions);
+    getRenderer(layer: Path): Renderer;
+
+    // Methods for layers and controls
+    addControl(control: Control): this;
+    removeControl(control: Control): this;
+    addLayer(layer: Layer): this;
+    removeLayer(layer: Layer): this;
+    hasLayer(layer: Layer): boolean;
+    eachLayer(fn: (layer: Layer) => void, context?: any): this;
+    openPopup(popup: Popup): this;
+    openPopup(content: Content, latlng: LatLngExpression, options?: PopupOptions): this;
+    closePopup(popup?: Popup): this;
+    openTooltip(tooltip: Tooltip): this;
+    openTooltip(content: Content, latlng: LatLngExpression, options?: TooltipOptions): this;
+    closeTooltip(tooltip?: Tooltip): this;
+
+    // Methods for modifying map state
+    setView(center: LatLngExpression, zoom: number, options?: ZoomPanOptions): this;
+    setZoom(zoom: number, options?: ZoomPanOptions): this;
+    zoomIn(delta?: number, options?: ZoomOptions): this;
+    zoomOut(delta?: number, options?: ZoomOptions): this;
+    setZoomAround(position: Point | LatLngExpression, zoom: number, options?: ZoomOptions): this;
+    fitBounds(bounds: LatLngBoundsExpression, options?: FitBoundsOptions): this;
+    fitWorld(options?: FitBoundsOptions): this;
+    panTo(latlng: LatLngExpression, options?: PanOptions): this;
+    panBy(offset: PointExpression): this;
+    setMaxBounds(bounds: LatLngBoundsExpression): this;
+    setMinZoom(zoom: number): this;
+    setMaxZoom(zoom: number): this;
+    panInsideBounds(bounds: LatLngBoundsExpression, options?: PanOptions): this;
     /**
-     * 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).
+     * Boolean for animate or advanced ZoomPanOptions
      */
-    abstract class Evented extends Class {
-        /**
-         * 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').
-         */
-        on(type: string, fn: EventHandlerFn, context?: any): this;
-
-        /**
-         * Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove}
-         */
-        on(eventMap: EventHandlerFnMap): this;
-
-        /* tslint:disable:unified-signatures */ // With an eventMap there are no additional arguments allowed
-        /**
-         * 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.
-         */
-        off(type: string, fn?: EventHandlerFn, context?: any): this;
-
-        /**
-         * Removes a set of type/listener pairs.
-         */
-        off(eventMap: EventHandlerFnMap): this;
-        /* tslint:enable */
-        /**
-         * Removes all listeners to all events on the object.
-         */
-        off(): 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.
-         */
-        fire(type: string, data?: any, propagate?: boolean): this;
-
-        /**
-         * Returns true if a particular event type has any listeners attached to it.
-         */
-        listens(type: string): boolean;
-
-        /**
-         * Behaves as on(...), except the listener will only get fired once and then removed.
-         */
-        once(type: string, fn: EventHandlerFn, context?: any): this;
-
-        /**
-         * Behaves as on(...), except the listener will only get fired once and then removed.
-         */
-        once(eventMap: EventHandlerFnMap): this;
-
-        /**
-         * Adds an event parent - an Evented that will receive propagated events
-         */
-        addEventParent(obj: Evented): this;
-
-        /**
-         * Removes an event parent, so it will stop receiving propagated events
-         */
-        removeEventParent(obj: Evented): 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').
-         */
-        addEventListener(type: string, fn: EventHandlerFn, context?: any): this;
-
-        /**
-         * Alias for on(...)
-         *
-         * Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove}
-         */
-        addEventListener(eventMap: EventHandlerFnMap): 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.
-         */
-        removeEventListener(type: string, fn: EventHandlerFn, context?: any): this;
-
-        /**
-         * Alias for off(...)
-         *
-         * Removes a set of type/listener pairs.
-         */
-        removeEventListener(eventMap: EventHandlerFnMap): this;
-
-        /**
-         * Alias for off()
-         *
-         * Removes all listeners to all events on the object.
-         */
-        clearAllEventListeners(): this;
-
-        /**
-         * Alias for once(...)
-         *
-         * Behaves as on(...), except the listener will only get fired once and then removed.
-         */
-        addOneTimeEventListener(type: string, fn: EventHandlerFn, context?: any): this;
-
-        /**
-         * Alias for once(...)
-         *
-         * Behaves as on(...), except the listener will only get fired once and then removed.
-         */
-        addOneTimeEventListener(eventMap: EventHandlerFnMap): 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.
-         */
-        fireEvent(type: string, data?: any, propagate?: boolean): this;
-
-        /**
-         * Alias for listens(...)
-         *
-         * Returns true if a particular event type has any listeners attached to it.
-         */
-        hasEventListeners(type: string): boolean;
-    }
+    invalidateSize(options?: boolean | ZoomPanOptions): this;
+    stop(): this;
+    flyTo(latlng: LatLngExpression, zoom?: number, options?: ZoomPanOptions): this;
+    flyToBounds(bounds: LatLngBoundsExpression, options?: FitBoundsOptions): this;
 
+    // Other methods
+    addHandler(name: string, HandlerClass: () => Handler): this; // HandlerClass is actually a constructor function, is this the right way?
+    remove(): this;
+    createPane(name: string, container?: HTMLElement): HTMLElement;
     /**
-     * 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).
+     * Name of the pane or the pane as HTML-Element
      */
-    class Draggable extends Evented {
-        constructor(element: HTMLElement, dragStartTarget?: HTMLElement, preventOutline?: boolean);
-
-        enable(): void;
-
-        disable(): void;
-
-        finishDrag(): void;
-    }
-
-    interface LayerOptions {
-        pane?: string;
-        attribution?: string;
-    }
-
-    interface InteractiveLayerOptions extends LayerOptions {
-        interactive?: boolean;
-    }
-
-    class Layer extends Evented {
-        constructor(options?: LayerOptions);
-        addTo(map: Map|LayerGroup): this;
-        remove(): this;
-        removeFrom(map: Map): this;
-        getPane(name?: string): HTMLElement | undefined;
-
-        // Popup methods
-        bindPopup(content: ((layer: Layer) => Content) | Content | Popup, options?: PopupOptions): this;
-        unbindPopup(): this;
-        openPopup(latlng?: LatLngExpression): this;
-        closePopup(): this;
-        togglePopup(): this;
-        isPopupOpen(): boolean;
-        setPopupContent(content: Content | Popup): this;
-        getPopup(): Popup | undefined;
-
-        // Tooltip methods
-        bindTooltip(content: ((layer: Layer) => Content) | Tooltip | Content, options?: TooltipOptions): this;
-        unbindTooltip(): this;
-        openTooltip(latlng?: LatLngExpression): this;
-        closeTooltip(): this;
-        toggleTooltip(): this;
-        isTooltipOpen(): boolean;
-        setTooltipContent(content: Content | Tooltip): this;
-        getTooltip(): Tooltip | undefined;
-
-        // Extension methods
-        onAdd(map: Map): this;
-        onRemove(map: Map): this;
-        getEvents?(): {[name: string]: (event: Event) => void};
-        getAttribution?(): string | null;
-        beforeAdd?(map: Map): this;
-    }
-
-    interface GridLayerOptions {
-        tileSize?: number | Point;
-        opacity?: number;
-        updateWhenIdle?: boolean;
-        updateWhenZooming?: boolean;
-        updateInterval?: number;
-        attribution?: string;
-        zIndex?: number;
-        bounds?: LatLngBoundsExpression;
-        minZoom?: number;
-        maxZoom?: number;
-        noWrap?: boolean;
-        pane?: string;
-        className?: string;
-        keepBuffer?: number;
-    }
-
-    class GridLayer extends Layer {
-        constructor(options?: GridLayerOptions);
-        bringToFront(): this;
-        bringToBack(): this;
-        getContainer(): HTMLElement | null;
-        setOpacity(opacity: number): this;
-        setZIndex(zIndex: number): this;
-        isLoading(): boolean;
-        redraw(): this;
-        getTileSize(): Point;
-    }
-
-    function gridLayer(options?: GridLayerOptions): GridLayer;
-
-    interface TileLayerOptions extends GridLayerOptions {
-        minZoom?: number;
-        maxZoom?: number;
-        maxNativeZoom?: number;
-        minNativeZoom?: number;
-        subdomains?: string | string[];
-        errorTileUrl?: string;
-        zoomOffset?: number;
-        tms?: boolean;
-        zoomReverse?: boolean;
-        detectRetina?: boolean;
-        crossOrigin?: boolean;
-        [name: string]: any;
-    }
-
-    class TileLayer extends GridLayer {
-        constructor(urlTemplate: string, options?: TileLayerOptions);
-        setUrl(url: string, noRedraw?: boolean): this;
-
-        options: TileLayerOptions;
-    }
-
-    function tileLayer(urlTemplate: string, options?: TileLayerOptions): TileLayer;
-
-    namespace TileLayer {
-        class WMS extends TileLayer {
-            constructor(baseUrl: string, options: WMSOptions);
-            setParams(params: WMSParams, noRedraw?: boolean): this;
-
-            wmsParams: WMSParams;
-            options: WMSOptions;
-        }
-    }
-
-    interface WMSOptions extends TileLayerOptions {
-        layers?: string;
-        styles?: string;
-        format?: string;
-        transparent?: boolean;
-        version?: string;
-        crs?: CRS;
-        uppercase?: boolean;
-    }
-
-    interface WMSParams {
-        format?: string;
-        layers: string;
-        request?: string;
-        service?: string;
-        styles?: string;
-        version?: string;
-        transparent?: boolean;
-        width?: number;
-        height?: number;
-    }
-
-    namespace tileLayer {
-        function wms(baseUrl: string, options?: WMSOptions): TileLayer.WMS;
-    }
-
-    interface ImageOverlayOptions extends LayerOptions {
-        opacity?: number;
-        alt?: string;
-        interactive?: boolean;
-        attribution?: string;
-        crossOrigin?: boolean;
-    }
-
-    class ImageOverlay extends Layer {
-        constructor(imageUrl: string, bounds: LatLngBoundsExpression, options?: ImageOverlayOptions);
-        setOpacity(opacity: number): this;
-        bringToFront(): this;
-        bringToBack(): this;
-        setUrl(url: string): this;
-
-        /** Update the bounds that this ImageOverlay covers */
-        setBounds(bounds: LatLngBounds): this;
-
-        /** Get the bounds that this ImageOverlay covers */
-        getBounds(): LatLngBounds;
-
-        /** Get the img element that represents the ImageOverlay on the map */
-        getElement(): HTMLImageElement | undefined;
-
-        options: ImageOverlayOptions;
-    }
-
-    function imageOverlay(imageUrl: string, bounds: LatLngBoundsExpression, options?: ImageOverlayOptions): ImageOverlay;
-
-    type LineCapShape = 'butt' | 'round' | 'square' | 'inherit';
-
-    type LineJoinShape = 'miter' | 'round' | 'bevel' | 'inherit';
-
-    type FillRule = 'nonzero' | 'evenodd' | 'inherit';
-
-    interface PathOptions extends InteractiveLayerOptions {
-        stroke?: boolean;
-        color?: string;
-        weight?: number;
-        opacity?: number;
-        lineCap?: LineCapShape;
-        lineJoin?: LineJoinShape;
-        dashArray?: string;
-        dashOffset?: string;
-        fill?: boolean;
-        fillColor?: string;
-        fillOpacity?: number;
-        fillRule?: FillRule;
-        renderer?: Renderer;
-        className?: string;
-    }
-
-    abstract class Path extends Layer {
-        redraw(): this;
-        setStyle(style: PathOptions): this;
-        bringToFront(): this;
-        bringToBack(): this;
-        getElement(): Element | undefined;
-
-        options: PathOptions;
-    }
-
-    interface PolylineOptions extends PathOptions {
-        smoothFactor?: number;
-        noClip?: boolean;
-    }
-
-    class InternalPolyline extends Path {
-        getLatLngs(): LatLng[];
-        setLatLngs(latlngs: LatLngExpression[]): this;
-        isEmpty(): boolean;
-        getCenter(): LatLng;
-        getBounds(): LatLngBounds;
-        addLatLng(latlng: LatLngExpression | LatLngExpression[]): this;
-
-        options: PolylineOptions;
-    }
-
-    class Polyline extends InternalPolyline {
-        constructor(latlngs: LatLngExpression[], options?: PolylineOptions);
-        toGeoJSON(): GeoJSONFeature<GeoJSONLineString | GeoJSONMultiLineString>;
-
-        feature?: GeoJSONFeature<GeoJSONLineString | GeoJSONMultiLineString>;
-    }
-
-    function polyline(latlngs: LatLngExpression[], options?: PolylineOptions): Polyline;
-
-    class Polygon extends InternalPolyline {
-        constructor(latlngs: LatLngExpression[] | LatLngExpression[][], options?: PolylineOptions);
-        toGeoJSON(): GeoJSONFeature<GeoJSONPolygon | GeoJSONMultiPolygon>;
-
-        feature?: GeoJSONFeature<GeoJSONPolygon | GeoJSONMultiPolygon>;
-    }
-
-    function polygon(latlngs: LatLngExpression[] | LatLngExpression[][], options?: PolylineOptions): Polygon;
-
-    class Rectangle extends Polygon {
-        constructor(latLngBounds: LatLngBoundsExpression, options?: PolylineOptions);
-        setBounds(latLngBounds: LatLngBoundsExpression): this;
-    }
-
-    function rectangle(latLngBounds: LatLngBoundsExpression, options?: PolylineOptions): Rectangle;
-
-    interface CircleMarkerOptions extends PathOptions {
-        radius?: number;
-    }
-
-    class CircleMarker extends Path {
-        constructor(latlng: LatLngExpression, options?: CircleMarkerOptions);
-        toGeoJSON(): GeoJSONFeature<GeoJSONPoint>;
-        setLatLng(latLng: LatLngExpression): this;
-        getLatLng(): LatLng;
-        setRadius(radius: number): this;
-        getRadius(): number;
-
-        options: CircleMarkerOptions;
-        feature?: GeoJSONFeature<GeoJSONPoint>;
-    }
-
-    function circleMarker(latlng: LatLngExpression, options?: CircleMarkerOptions): CircleMarker;
-
-    class Circle extends CircleMarker {
-        constructor(latlng: LatLngExpression, options?: CircleMarkerOptions);
-        constructor(latlng: LatLngExpression, radius: number, options?: CircleMarkerOptions); // deprecated!
-        getBounds(): LatLngBounds;
-    }
-
-    function circle(latlng: LatLngExpression, options?: CircleMarkerOptions): Circle;
-    function circle(latlng: LatLngExpression, radius: number, options?: CircleMarkerOptions): Circle; // deprecated!
-
-    interface RendererOptions extends LayerOptions {
-        padding?: number;
-    }
-
-    class Renderer extends Layer {
-        constructor(options?: RendererOptions);
-
-        options: RendererOptions;
-    }
-
-    class SVG extends Renderer {}
-
-    namespace SVG {
-        function create(name: string): SVGElement;
-
-        function pointsToPath(rings: PointExpression[], close: boolean): string;
-    }
-
-    function svg(options?: RendererOptions): SVG;
-
-    class Canvas extends Renderer {}
-
-    function canvas(options?: RendererOptions): Canvas;
-
-    /**
-     * 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.
-     */
-    class LayerGroup extends Layer {
-        constructor(layers?: Layer[]);
-        /**
-         * Returns a GeoJSON representation of the layer group (as a GeoJSON GeometryCollection, GeoJSONFeatureCollection or Multipoint).
-         */
-        toGeoJSON(): GeoJSONFeatureCollection<GeoJSONGeometryObject> | GeoJSONFeature<GeoJSONMultiPoint> | GeoJSONGeometryCollection;
-
-        /**
-         * Adds the given layer to the group.
-         */
-        addLayer(layer: Layer): this;
-
-        /**
-         * Removes the layer with the given internal ID or the given layer from the group.
-         */
-        removeLayer(layer: number | Layer): this;
-
-        /**
-         * Returns true if the given layer is currently added to the group.
-         */
-        hasLayer(layer: Layer): boolean;
-
-        /**
-         * Removes all the layers from the group.
-         */
-        clearLayers(): 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.
-         */
-        invoke(methodName: string, ...params: any[]): this;
-
-        /**
-         * Iterates over the layers of the group,
-         * optionally specifying context of the iterator function.
-         */
-        eachLayer(fn: (layer: Layer) => void, context?: any): this;
-
-        /**
-         * Returns the layer with the given internal ID.
-         */
-        getLayer(id: number): Layer | undefined;
-
-        /**
-         * Returns an array of all the layers added to the group.
-         */
-        getLayers(): Layer[];
-
-        /**
-         * Calls setZIndex on every layer contained in this group, passing the z-index.
-         */
-        setZIndex(zIndex: number): this;
-
-        /**
-         * Returns the internal ID for a layer
-         */
-        getLayerId(layer: Layer): number;
-
-        feature?: GeoJSONFeatureCollection<GeoJSONGeometryObject> | GeoJSONFeature<GeoJSONMultiPoint> | GeoJSONGeometryCollection;
-    }
-
-    /**
-     * Create a layer group, optionally given an initial set of layers.
-     */
-    function layerGroup(layers: Layer[]): LayerGroup;
-
-    /**
-     * Extended LayerGroup that also has mouse events (propagated from
-     * members of the group) and a shared bindPopup method.
-     */
-    class FeatureGroup extends LayerGroup {
-        /**
-         * Sets the given path options to each layer of the group that has a setStyle method.
-         */
-        setStyle(style: StyleFunction): this;
-
-        /**
-         * Brings the layer group to the top of all other layers
-         */
-        bringToFront(): this;
-
-        /**
-         * Brings the layer group to the top [sic] of all other layers
-         */
-        bringToBack(): this;
-
-        /**
-         * Returns the LatLngBounds of the Feature Group (created from
-         * bounds and coordinates of its children).
-         */
-        getBounds(): LatLngBounds;
-    }
-
-    /**
-     * Create a feature group, optionally given an initial set of layers.
-     */
-    function featureGroup(layers?: Layer[]): FeatureGroup;
-
-    type StyleFunction = (feature?: GeoJSONFeature<GeoJSONGeometryObject>) => PathOptions;
-
-    interface GeoJSONOptions extends LayerOptions {
-        /**
-         * A Function defining how GeoJSON points spawn Leaflet layers.
-         * It is internally called when data is added, passing the GeoJSON point
-         * feature and its LatLng.
-         *
-         * The default is to spawn a default Marker:
-         *
-         * ```
-         * function(geoJsonPoint, latlng) {
-         *     return L.marker(latlng);
-         * }
-         * ```
-         */
-        pointToLayer?(geoJsonPoint: GeoJSONFeature<GeoJSONPoint>, latlng: LatLng): Layer; // should import GeoJSON typings
-
-        /**
-         * A Function defining the Path options for styling GeoJSON lines and polygons,
-         * called internally when data is added.
-         *
-         * The default value is to not override any defaults:
-         *
-         * ```
-         * function (geoJsonFeature) {
-         *     return {}
-         * }
-         * ```
-         */
-        style?: StyleFunction;
-
-        /**
-         * A Function that will be called once for each created Feature, after it
-         * has been created and styled. Useful for attaching events and popups to features.
-         *
-         * The default is to do nothing with the newly created layers:
-         *
-         * ```
-         * function (feature, layer) {}
-         * ```
-         */
-        onEachFeature?(feature: GeoJSONFeature<GeoJSONGeometryObject>, layer: Layer): void;
-
-        /**
-         * A Function that will be used to decide whether to show a feature or not.
-         *
-         * The default is to show all features:
-         *
-         * ```
-         * function (geoJsonFeature) {
-         *     return true;
-         * }
-         * ```
-         */
-        filter?(geoJsonFeature: GeoJSONFeature<GeoJSONGeometryObject>): boolean;
-
-        /**
-         * A Function that will be used for converting GeoJSON coordinates to LatLngs.
-         * The default is the coordsToLatLng static method.
-         */
-        coordsToLatLng?(coords: [number, number] | [number, number, number]): LatLng; // check if LatLng has an altitude property
-    }
-
-    /**
-     * Represents a GeoJSON object or an array of GeoJSON objects.
-     * Allows you to parse GeoJSON data and display it on the map. Extends FeatureGroup.
-     */
-    class GeoJSON extends FeatureGroup {
-        /**
-         * Creates a Layer from a given GeoJSON feature. Can use a custom pointToLayer
-         * and/or coordsToLatLng functions if provided as options.
-         */
-        static geometryToLayer(featureData: GeoJSONFeature<GeoJSONGeometryObject>, options?: GeoJSONOptions): Layer;
-
-        /**
-         * Creates a LatLng object from an array of 2 numbers (longitude, latitude) or
-         * 3 numbers (longitude, latitude, altitude) used in GeoJSON for points.
-         */
-        static coordsToLatLng(coords: [number, number] | [number, number, number]): LatLng;
-
-        /**
-         * 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.
-         */
-        static coordsToLatLngs(
-            coords: any[],
-            levelsDeep?: number,
-            coordsToLatLng?: (coords: [number, number] | [number, number, number]) => LatLng): any[]; // Using any[] to avoid artificially limiting valid calls
-
-        /**
-         * Reverse of coordsToLatLng
-         */
-        static latLngToCoords(latlng: LatLng): [number, number] | [number, number, number];
-
-        /**
-         * 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.
-         */
-        static latLngsToCoords(latlngs: any[], levelsDeep?: number, closed?: boolean): any[];  // Using any[] to avoid artificially limiting valid calls
-
-        /**
-         * Normalize GeoJSON geometries/features into GeoJSON features.
-         */
-        static asFeature(geojson: GeoJSONFeature<GeoJSONGeometryObject> | GeoJSONGeometryObject): GeoJSONFeature<GeoJSONGeometryObject>;
-
-        constructor(geojson?: GeoJSONGeoJsonObject, options?: GeoJSONOptions)
-        /**
-         * Adds a GeoJSON object to the layer.
-         */
-        addData(data: GeoJSONGeoJsonObject): Layer;
-
-        /**
-         * Resets the given vector layer's style to the original GeoJSON style,
-         * useful for resetting style after hover events.
-         */
-        resetStyle(layer: Layer): Layer;
-
-        /**
-         * Changes styles of GeoJSON vector layers with the given style function.
-         */
-        setStyle(style: StyleFunction): this;
-
-        options: GeoJSONOptions;
-    }
-
-    /**
-     * 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 geoJSON(geojson?: GeoJSONGeoJsonObject, options?: GeoJSONOptions): GeoJSON;
-
-    type Zoom = boolean | 'center';
-
-    interface MapOptions {
-        preferCanvas?: boolean;
-
-        // Control options
-        attributionControl?: boolean;
-        zoomControl?: boolean;
-
-        // Interaction options
-        closePopupOnClick?: boolean;
-        zoomSnap?: number;
-        zoomDelta?: number;
-        trackResize?: boolean;
-        boxZoom?: boolean;
-        doubleClickZoom?: Zoom;
-        dragging?: boolean;
-
-        // Map state options
-        crs?: CRS;
-        center?: LatLngExpression;
-        zoom?: number;
-        minZoom?: number;
-        maxZoom?: number;
-        layers?: Layer[];
-        maxBounds?: LatLngBoundsExpression;
-        renderer?: Renderer;
-
-        // Animation options
-        fadeAnimation?: boolean;
-        markerZoomAnimation?: boolean;
-        transform3DLimit?: number;
-        zoomAnimation?: boolean;
-        zoomAnimationThreshold?: number;
-
-        // Panning inertia options
-        inertia?: boolean;
-        inertiaDeceleration?: number;
-        inertiaMaxSpeed?: number;
-        easeLinearity?: number;
-        worldCopyJump?: boolean;
-        maxBoundsViscosity?: number;
-
-        // Keyboard navigation options
-        keyboard?: boolean;
-        keyboardPanDelta?: number;
-
-        // Mousewheel options
-        scrollWheelZoom?: Zoom;
-        wheelDebounceTime?: number;
-        wheelPxPerZoomLevel?: number;
-
-        // Touch interaction options
-        tap?: boolean;
-        tapTolerance?: number;
-        touchZoom?: Zoom;
-        bounceAtZoomLimits?: boolean;
-    }
-
-    type ControlPosition = 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
-
-    interface ControlOptions {
-        position?: ControlPosition;
-    }
-
-    class Control extends Class {
-        constructor(options?: ControlOptions);
-        getPosition(): ControlPosition;
-        setPosition(position: ControlPosition): this;
-        getContainer(): HTMLElement | undefined;
-        addTo(map: Map): this;
-        remove(): this;
-
-        // Extension methods
-        onAdd?(map: Map): HTMLElement;
-        onRemove?(map: Map): void;
-
-        options: ControlOptions;
-    }
-
-    namespace Control {
-        interface ZoomOptions extends ControlOptions {
-            zoomInText?: string;
-            zoomInTitle?: string;
-            zoomOutText?: string;
-            zoomOutTitle?: string;
-        }
-
-        class Zoom extends Control {
-            constructor(options?: ZoomOptions);
-            options: ZoomOptions;
-        }
-
-        interface AttributionOptions extends ControlOptions {
-            prefix?: string | boolean;
-        }
-
-        class Attribution extends Control {
-            constructor(options?: AttributionOptions);
-            setPrefix(prefix: string): this;
-            addAttribution(text: string): this;
-            removeAttribution(text: string): this;
-            options: AttributionOptions;
-        }
-
-        interface LayersOptions extends ControlOptions {
-            collapsed?: boolean;
-            autoZIndex?: boolean;
-            hideSingleBase?: boolean;
-        }
-
-        interface LayersObject {
-            [name: string]: Layer;
-        }
-
-        class Layers extends Control {
-            constructor(baseLayers?: LayersObject, overlays?: LayersObject, options?: LayersOptions);
-            addBaseLayer(layer: Layer, name: string): this;
-            addOverlay(layer: Layer, name: string): this;
-            removeLayer(layer: Layer): this;
-            expand(): this;
-            collapse(): this;
-            options: LayersOptions;
-        }
-
-        interface ScaleOptions extends ControlOptions {
-            maxWidth?: number;
-            metric?: boolean;
-            imperial?: boolean;
-            updateWhenIdle?: boolean;
-        }
-
-        class Scale extends Control {
-            constructor(options?: ScaleOptions);
-            options: ScaleOptions;
-        }
-    }
-
-    namespace control {
-        function zoom(options?: Control.ZoomOptions): Control.Zoom;
-
-        function attribution(options?: Control.AttributionOptions): Control.Attribution;
-
-        function layers(baseLayers?: Control.LayersObject, overlays?: Control.LayersObject, options?: Control.LayersOptions): Control.Layers;
-
-        function scale(options?: Control.ScaleOptions): Control.Scale;
-    }
-
-    interface DivOverlayOptions {
-        offset?: PointExpression;
-        zoomAnimation?: boolean;
-        className?: string;
-        pane?: string;
-    }
-
-    interface PopupOptions extends DivOverlayOptions {
-        maxWidth?: number;
-        minWidth?: number;
-        maxHeight?: number;
-        autoPan?: boolean;
-        autoPanPaddingTopLeft?: PointExpression;
-        autoPanPaddingBottomRight?: PointExpression;
-        autoPanPadding?: PointExpression;
-        keepInView?: boolean;
-        closeButton?: boolean;
-        autoClose?: boolean;
-        closeOnClick?: boolean;
-    }
-
-    type Content = string | HTMLElement;
-
-    class Popup extends Layer {
-        constructor(options?: PopupOptions, source?: Layer);
-        getLatLng(): LatLng | undefined;
-        setLatLng(latlng: LatLngExpression): this;
-        getContent(): Content | ((source: Layer) => Content) | undefined;
-        setContent(htmlContent: ((source: Layer) => Content) | Content): this;
-        getElement(): HTMLElement | undefined;
-        update(): void;
-        isOpen(): boolean;
-        bringToFront(): this;
-        bringToBack(): this;
-        openOn(map: Map): this;
-
-        options: PopupOptions;
-    }
-
-    function popup(options?: PopupOptions, source?: Layer): Popup;
-
-    type Direction = 'right' | 'left' | 'top' | 'bottom' | 'center' | 'auto';
-
-    interface TooltipOptions extends DivOverlayOptions {
-        pane?: string;
-        offset?: PointExpression;
-        direction?: Direction;
-        permanent?: boolean;
-        sticky?: boolean;
-        interactive?: boolean;
-        opacity?: number;
-    }
-
-    class Tooltip extends Layer {
-        constructor(options?: TooltipOptions, source?: Layer);
-        setOpacity(val: number): void;
-        getLatLng(): LatLng | undefined;
-        setLatLng(latlng: LatLngExpression): this;
-        getContent(): Content | undefined;
-        setContent(htmlContent: ((source: Layer) => Content) | Content): this;
-        getElement(): HTMLElement | undefined;
-        update(): void;
-        isOpen(): boolean;
-        bringToFront(): this;
-        bringToBack(): this;
-
-        options: TooltipOptions;
-    }
-
-    function tooltip(options?: TooltipOptions, source?: Layer): Tooltip;
-
-    interface ZoomOptions {
-        animate?: boolean;
-    }
-
-    interface PanOptions {
-        animate?: boolean;
-        duration?: number;
-        easeLinearity?: number;
-        noMoveStart?: boolean;
-    }
-
-    /* tslint:disable:no-empty-interface */ // This is not empty, it extends two interfaces into one...
-    interface ZoomPanOptions extends ZoomOptions, PanOptions {}
-    /* tslint:enable */
-
-    interface FitBoundsOptions extends ZoomOptions, PanOptions {
-        paddingTopLeft?: PointExpression;
-        paddingBottomRight?: PointExpression;
-        padding?: PointExpression;
-        maxZoom?: number;
-    }
-
-    interface LocateOptions {
-        watch?: boolean;
-        setView?: boolean;
-        maxZoom?: number;
-        timeout?: number;
-        maximumAge?: number;
-        enableHighAccuracy?: boolean;
-    }
-
-    class Handler extends Class {
-        constructor(map: Map);
-        enable(): this;
-        disable(): this;
-        enabled(): boolean;
-
-        // Extension methods
-        addHooks?(): void;
-        removeHooks?(): void;
-    }
-
-    interface Event {
-        type: string;
-        target: any;
-    }
-
-    interface MouseEvent extends Event {
-        latlng: LatLng;
-        layerPoint: Point;
-        containerPoint: Point;
-        originalEvent: NativeMouseEvent;
-    }
-
-    interface KeyboardEvent extends Event {
-        originalEvent: NativeKeyboardEvent;
-    }
-
-    interface LocationEvent extends Event {
-        latlng: LatLng;
-        bounds: LatLngBounds;
-        accuracy: number;
-        altitude: number;
-        altitudeAccuracy: number;
-        heading: number;
-        speed: number;
-        timestamp: number;
-    }
-
-    interface ErrorEvent extends Event {
-        message: string;
-        code: number;
-    }
-
-    interface LayerEvent extends Event {
-        layer: Layer;
-    }
-
-    interface LayersControlEvent extends LayerEvent {
-        name: string;
-    }
-
-    interface TileEvent extends Event {
-        tile: HTMLImageElement;
-        coords: Point; // apparently not a normal point, since docs say it has z (zoom)
-    }
-
-    interface TileErrorEvent extends TileEvent {
-        error: Error;
-    }
-
-    interface ResizeEvent extends Event {
-        oldSize: Point;
-        newSize: Point;
-    }
-
-    interface GeoJSONEvent extends Event {
-        layer: Layer;
-        properties: any;
-        geometryType: string;
-        id: string;
-    }
-
-    interface PopupEvent extends Event {
-        popup: Popup;
-    }
-
-    interface TooltipEvent extends Event {
-        tooltip: Tooltip;
-    }
-
-    interface DragEndEvent extends Event {
-        distance: number;
-    }
-
-    interface ZoomAnimEvent extends Event {
-        center: LatLng;
-        zoom: number;
-        noUpdate: boolean;
-    }
-
-    namespace DomEvent {
-        function on(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
-
-        function on(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
-
-        function off(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
-
-        function off(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
-
-        function stopPropagation(ev: Event): typeof DomEvent;
-
-        function disableScrollPropagation(el: HTMLElement): typeof DomEvent;
-
-        function disableClickPropagation(el: HTMLElement): typeof DomEvent;
-
-        function preventDefault(ev: Event): typeof DomEvent;
-
-        function stop(ev: Event): typeof DomEvent;
-
-        function getMousePosition(ev: {clientX: number, clientY: number} /*MouseEvent from lib.d.ts*/, container?: HTMLElement): Point;
-
-        function getWheelDelta(ev: Event): number;
-
-        function addListener(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
-
-        function addListener(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
-
-        function removeListener(el: HTMLElement, types: string, fn: EventHandlerFn, context?: any): typeof DomEvent;
-
-        function removeListener(el: HTMLElement, eventMap: {[eventName: string]: EventHandlerFn}, context?: any): typeof DomEvent;
-    }
-
-    interface DefaultMapPanes {
-        mapPane: HTMLElement;
-        tilePane: HTMLElement;
-        overlayPane: HTMLElement;
-        shadowPane: HTMLElement;
-        markerPane: HTMLElement;
-        tooltipPane: HTMLElement;
-        popupPane: HTMLElement;
-    }
-
-    class Map extends Evented {
-        constructor(element: string | HTMLElement, options?: MapOptions);
-        getRenderer(layer: Path): Renderer;
-
-        // Methods for layers and controls
-        addControl(control: Control): this;
-        removeControl(control: Control): this;
-        addLayer(layer: Layer): this;
-        removeLayer(layer: Layer): this;
-        hasLayer(layer: Layer): boolean;
-        eachLayer(fn: (layer: Layer) => void, context?: any): this;
-        openPopup(popup: Popup): this;
-        openPopup(content: Content, latlng: LatLngExpression, options?: PopupOptions): this;
-        closePopup(popup?: Popup): this;
-        openTooltip(tooltip: Tooltip): this;
-        openTooltip(content: Content, latlng: LatLngExpression, options?: TooltipOptions): this;
-        closeTooltip(tooltip?: Tooltip): this;
-
-        // Methods for modifying map state
-        setView(center: LatLngExpression, zoom: number, options?: ZoomPanOptions): this;
-        setZoom(zoom: number, options?: ZoomPanOptions): this;
-        zoomIn(delta?: number, options?: ZoomOptions): this;
-        zoomOut(delta?: number, options?: ZoomOptions): this;
-        setZoomAround(position: Point | LatLngExpression, zoom: number, options?: ZoomOptions): this;
-        fitBounds(bounds: LatLngBoundsExpression, options?: FitBoundsOptions): this;
-        fitWorld(options?: FitBoundsOptions): this;
-        panTo(latlng: LatLngExpression, options?: PanOptions): this;
-        panBy(offset: PointExpression): this;
-        setMaxBounds(bounds: LatLngBoundsExpression): this;
-        setMinZoom(zoom: number): this;
-        setMaxZoom(zoom: number): this;
-        panInsideBounds(bounds: LatLngBoundsExpression, options?: PanOptions): this;
-        /**
-         * Boolean for animate or advanced ZoomPanOptions
-         */
-        invalidateSize(options?: boolean | ZoomPanOptions): this;
-        stop(): this;
-        flyTo(latlng: LatLngExpression, zoom?: number, options?: ZoomPanOptions): this;
-        flyToBounds(bounds: LatLngBoundsExpression, options?: FitBoundsOptions): this;
-
-        // Other methods
-        addHandler(name: string, HandlerClass: () => Handler): this; // HandlerClass is actually a constructor function, is this the right way?
-        remove(): this;
-        createPane(name: string, container?: HTMLElement): HTMLElement;
-        /**
-         * Name of the pane or the pane as HTML-Element
-         */
-        getPane(pane: string | HTMLElement): HTMLElement | undefined;
-        getPanes(): {[name: string]: HTMLElement} & DefaultMapPanes;
-        getContainer(): HTMLElement;
-        whenReady(fn: () => void, context?: any): this;
-
-        // Methods for getting map state
-        getCenter(): LatLng;
-        getZoom(): number;
-        getBounds(): LatLngBounds;
-        getMinZoom(): number;
-        getMaxZoom(): number;
-        getBoundsZoom(bounds: LatLngBoundsExpression, inside?: boolean): number;
-        getSize(): Point;
-        getPixelBounds(): Bounds;
-        getPixelOrigin(): Point;
-        getPixelWorldBounds(zoom?: number): Bounds;
-
-        // Conversion methods
-        getZoomScale(toZoom: number, fromZoom: number): number;
-        getScaleZoom(scale: number, fromZoom: number): number;
-        project(latlng: LatLngExpression, zoom: number): Point;
-        unproject(point: PointExpression, zoom: number): LatLng;
-        layerPointToLatLng(point: PointExpression): LatLng;
-        latLngToLayerPoint(latlng: LatLngExpression): Point;
-        wrapLatLng(latlng: LatLngExpression): LatLng;
-        wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds;
-        distance(latlng1: LatLngExpression, latlng2: LatLngExpression): number;
-        containerPointToLayerPoint(point: PointExpression): Point;
-        containerPointToLatLng(point: PointExpression): LatLng;
-        layerPointToContainerPoint(point: PointExpression): Point;
-        latLngToContainerPoint(latlng: LatLngExpression): Point;
-        mouseEventToContainerPoint(ev: MouseEvent): Point;
-        mouseEventToLayerPoint(ev: MouseEvent): Point;
-        mouseEventToLatLng(ev: MouseEvent): LatLng;
-
-        // Geolocation methods
-        locate(options?: LocateOptions): this;
-        stopLocate(): this;
-
-        // Properties
-        boxZoom: Handler;
-        doubleClickZoom: Handler;
-        dragging: Handler;
-        keyboard: Handler;
-        scrollWheelZoom: Handler;
-        tap?: Handler;
-        touchZoom: Handler;
-
-        options: MapOptions;
-    }
-
-    /**
-     * ID of a HTML-Element as string or the HTML-ELement itself
-     */
-    function map(element: string | HTMLElement, options?: MapOptions): Map;
-
-    interface BaseIconOptions extends LayerOptions {
-        iconUrl?: string;
-        iconRetinaUrl?: string;
-        iconSize?: PointExpression;
-        iconAnchor?: PointExpression;
-        popupAnchor?: PointExpression;
-        shadowUrl?: string;
-        shadowRetinaUrl?: string;
-        shadowSize?: PointExpression;
-        shadowAnchor?: PointExpression;
-        className?: string;
-    }
-
-    interface IconOptions extends BaseIconOptions {
-        iconUrl: string;
-    }
-
-    // This class does not exist in reality, it's just a way to provide
-    // options of more specific types in the sub classes
-    class BaseIcon extends Layer {
-        createIcon(oldIcon?: HTMLElement): HTMLElement;
-        createShadow(oldIcon?: HTMLElement): HTMLElement;
-        options: BaseIconOptions;
-    }
-
-    class Icon extends BaseIcon {
-        constructor(options: IconOptions);
-        options: IconOptions;
-    }
-
-    namespace Icon {
-        interface DefaultIconOptions extends BaseIconOptions {
-            imagePath?: string;
-        }
-
-        class Default extends BaseIcon {
-            static imagePath?: string;
-            constructor(options?: DefaultIconOptions);
-            options: DefaultIconOptions;
-        }
-    }
-
-    function icon(options: IconOptions): Icon;
-
-    interface DivIconOptions extends BaseIconOptions {
-        html?: string | false;
-        bgPos?: PointExpression;
-        iconSize?: PointExpression;
-        iconAnchor?: PointExpression;
-        popupAnchor?: PointExpression;
-        className?: string;
-    }
-
-    class DivIcon extends BaseIcon {
-        constructor(options?: DivIconOptions);
-        options: DivIconOptions;
-    }
-
-    function divIcon(options?: DivIconOptions): DivIcon;
-
-    interface MarkerOptions extends InteractiveLayerOptions {
-        icon?: Icon | DivIcon;
-        clickable?: boolean;
-        draggable?: boolean;
-        keyboard?: boolean;
-        title?: string;
-        alt?: string;
-        zIndexOffset?: number;
-        opacity?: number;
-        riseOnHover?: boolean;
-        riseOffset?: number;
-    }
-
-    class Marker extends Layer {
-        constructor(latlng: LatLngExpression, options?: MarkerOptions);
-        getLatLng(): LatLng;
-        setLatLng(latlng: LatLngExpression): this;
-        setZIndexOffset(offset: number): this;
-        setIcon(icon: Icon | DivIcon): this;
-        setOpacity(opacity: number): this;
-        getElement(): HTMLElement | undefined;
-
-        // Properties
-        options: MarkerOptions;
-        dragging?: Handler;
-    }
-
-    function marker(latlng: LatLngExpression, options?: MarkerOptions): Marker;
-
-    namespace Browser {
-        const ie: boolean;
-        const ielt9: boolean;
-        const edge: boolean;
-        const webkit: boolean;
-        const gecko: boolean;
-        const android: boolean;
-        const android23: boolean;
-        const chrome: boolean;
-        const safari: boolean;
-        const win: boolean;
-        const ie3d: boolean;
-        const webkit3d: boolean;
-        const gecko3d: boolean;
-        const opera12: boolean;
-        const any3d: boolean;
-        const mobile: boolean;
-        const mobileWebkit: boolean;
-        const mobileWebkit3d: boolean;
-        const mobileOpera: boolean;
-        const mobileGecko: boolean;
-        const touch: boolean;
-        const msPointer: boolean;
-        const pointer: boolean;
-        const retina: boolean;
-        const canvas: boolean;
-        const vml: boolean;
-        const svg: boolean;
-    }
-
-    namespace Util {
-        function extend(dest: any, src?: any): any;
-        function create(proto: any, properties?: any): any;
-        function bind(fn: () => void, ...obj: any[]): () => void;
-        function stamp(obj: any): number;
-        function throttle(fn: () => void, time: number, context: any): () => void;
-        function wrapNum(num: number, range: number[], includeMax?: boolean): number;
-        function falseFn(): false;
-        function formatNum(num: number, digits?: number): number;
-        function trim(str: string): string;
-        function splitWords(str: string): string[];
-        function setOptions(obj: any, options: any): any;
-        function getParamString(obj: any, existingUrl?: string, uppercase?: boolean): string;
-        function template(str: string, data: any): string;
-        function isArray(obj: any): boolean;
-        function indexOf(array: any[], el: any): number;
-        function requestAnimFrame(fn: () => void, context?: any, immediate?: boolean): number;
-        function cancelAnimFrame(id: number): void;
-
-        let lastId: number;
-        let emptyImageUrl: string;
+    getPane(pane: string | HTMLElement): HTMLElement | undefined;
+    getPanes(): {[name: string]: HTMLElement} & DefaultMapPanes;
+    getContainer(): HTMLElement;
+    whenReady(fn: () => void, context?: any): this;
+
+    // Methods for getting map state
+    getCenter(): LatLng;
+    getZoom(): number;
+    getBounds(): LatLngBounds;
+    getMinZoom(): number;
+    getMaxZoom(): number;
+    getBoundsZoom(bounds: LatLngBoundsExpression, inside?: boolean): number;
+    getSize(): Point;
+    getPixelBounds(): Bounds;
+    getPixelOrigin(): Point;
+    getPixelWorldBounds(zoom?: number): Bounds;
+
+    // Conversion methods
+    getZoomScale(toZoom: number, fromZoom: number): number;
+    getScaleZoom(scale: number, fromZoom: number): number;
+    project(latlng: LatLngExpression, zoom: number): Point;
+    unproject(point: PointExpression, zoom: number): LatLng;
+    layerPointToLatLng(point: PointExpression): LatLng;
+    latLngToLayerPoint(latlng: LatLngExpression): Point;
+    wrapLatLng(latlng: LatLngExpression): LatLng;
+    wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds;
+    distance(latlng1: LatLngExpression, latlng2: LatLngExpression): number;
+    containerPointToLayerPoint(point: PointExpression): Point;
+    containerPointToLatLng(point: PointExpression): LatLng;
+    layerPointToContainerPoint(point: PointExpression): Point;
+    latLngToContainerPoint(latlng: LatLngExpression): Point;
+    mouseEventToContainerPoint(ev: MouseEvent): Point;
+    mouseEventToLayerPoint(ev: MouseEvent): Point;
+    mouseEventToLatLng(ev: MouseEvent): LatLng;
+
+    // Geolocation methods
+    locate(options?: LocateOptions): this;
+    stopLocate(): this;
+
+    // Properties
+    boxZoom: Handler;
+    doubleClickZoom: Handler;
+    dragging: Handler;
+    keyboard: Handler;
+    scrollWheelZoom: Handler;
+    tap?: Handler;
+    touchZoom: Handler;
+
+    options: MapOptions;
+}
+
+/**
+ * ID of a HTML-Element as string or the HTML-ELement itself
+ */
+export function map(element: string | HTMLElement, options?: MapOptions): Map;
+
+export interface BaseIconOptions extends LayerOptions {
+    iconUrl?: string;
+    iconRetinaUrl?: string;
+    iconSize?: PointExpression;
+    iconAnchor?: PointExpression;
+    popupAnchor?: PointExpression;
+    shadowUrl?: string;
+    shadowRetinaUrl?: string;
+    shadowSize?: PointExpression;
+    shadowAnchor?: PointExpression;
+    className?: string;
+}
+
+export interface IconOptions extends BaseIconOptions {
+    iconUrl: string;
+}
+
+export class Icon<T extends BaseIconOptions = IconOptions> extends Layer {
+    constructor(options: T);
+    createIcon(oldIcon?: HTMLElement): HTMLElement;
+    createShadow(oldIcon?: HTMLElement): HTMLElement;
+
+    options: T;
+}
+
+export namespace Icon {
+    interface DefaultIconOptions extends BaseIconOptions {
+        imagePath?: string;
+    }
+
+    class Default extends Icon<DefaultIconOptions> {
+        static imagePath?: string;
+        constructor(options?: DefaultIconOptions);
     }
 }
 
-declare module 'leaflet' {
-    export = L;
+export function icon(options: IconOptions): Icon;
+
+export interface DivIconOptions extends BaseIconOptions {
+    html?: string | false;
+    bgPos?: PointExpression;
+    iconSize?: PointExpression;
+    iconAnchor?: PointExpression;
+    popupAnchor?: PointExpression;
+    className?: string;
+}
+
+export class DivIcon extends Icon<DivIconOptions> {
+    constructor(options?: DivIconOptions);
+}
+
+export function divIcon(options?: DivIconOptions): DivIcon;
+
+export interface MarkerOptions extends InteractiveLayerOptions {
+    icon?: Icon | DivIcon;
+    clickable?: boolean;
+    draggable?: boolean;
+    keyboard?: boolean;
+    title?: string;
+    alt?: string;
+    zIndexOffset?: number;
+    opacity?: number;
+    riseOnHover?: boolean;
+    riseOffset?: number;
+}
+
+export class Marker extends Layer {
+    constructor(latlng: LatLngExpression, options?: MarkerOptions);
+    getLatLng(): LatLng;
+    setLatLng(latlng: LatLngExpression): this;
+    setZIndexOffset(offset: number): this;
+    setIcon(icon: Icon | DivIcon): this;
+    setOpacity(opacity: number): this;
+    getElement(): HTMLElement | undefined;
+
+    // Properties
+    options: MarkerOptions;
+    dragging?: Handler;
+}
+
+export function marker(latlng: LatLngExpression, options?: MarkerOptions): Marker;
+
+export namespace Browser {
+    const ie: boolean;
+    const ielt9: boolean;
+    const edge: boolean;
+    const webkit: boolean;
+    const gecko: boolean;
+    const android: boolean;
+    const android23: boolean;
+    const chrome: boolean;
+    const safari: boolean;
+    const win: boolean;
+    const ie3d: boolean;
+    const webkit3d: boolean;
+    const gecko3d: boolean;
+    const opera12: boolean;
+    const any3d: boolean;
+    const mobile: boolean;
+    const mobileWebkit: boolean;
+    const mobileWebkit3d: boolean;
+    const mobileOpera: boolean;
+    const mobileGecko: boolean;
+    const touch: boolean;
+    const msPointer: boolean;
+    const pointer: boolean;
+    const retina: boolean;
+    const canvas: boolean;
+    const vml: boolean;
+    const svg: boolean;
+}
+
+export namespace Util {
+    function extend(dest: any, src?: any): any;
+    function create(proto: any, properties?: any): any;
+    function bind(fn: () => void, ...obj: any[]): () => void;
+    function stamp(obj: any): number;
+    function throttle(fn: () => void, time: number, context: any): () => void;
+    function wrapNum(num: number, range: number[], includeMax?: boolean): number;
+    function falseFn(): false;
+    function formatNum(num: number, digits?: number): number;
+    function trim(str: string): string;
+    function splitWords(str: string): string[];
+    function setOptions(obj: any, options: any): any;
+    function getParamString(obj: any, existingUrl?: string, uppercase?: boolean): string;
+    function template(str: string, data: any): string;
+    function isArray(obj: any): boolean;
+    function indexOf(array: any[], el: any): number;
+    function requestAnimFrame(fn: () => void, context?: any, immediate?: boolean): number;
+    function cancelAnimFrame(id: number): void;
+
+    let lastId: number;
+    let emptyImageUrl: string;
 }
diff --git a/types/leaflet/leaflet-tests.ts b/types/leaflet/leaflet-tests.ts
index d6b9a3e87f..b85c8bf4d7 100644
--- a/types/leaflet/leaflet-tests.ts
+++ b/types/leaflet/leaflet-tests.ts
@@ -1,4 +1,4 @@
-import L = require('leaflet');
+import * as L from 'leaflet';
 
 const latLngLiteral: L.LatLngLiteral = {lat: 12, lng: 13};
 const latLngTuple: L.LatLngTuple = [12, 13];
@@ -451,8 +451,8 @@ L.marker([1, 2], {
 }));
 
 const latLngs = [
-  { lat: 0, lng: 0 },
-  { lat: 1, lng: 1 }
+  {lat: 0, lng: 0},
+  {lat: 1, lng: 1}
 ];
 const polygon = new L.Polygon(latLngs);
 const polygonExclusion = new L.Polygon([latLngs, latLngs]);
diff --git a/types/proj4leaflet/index.d.ts b/types/proj4leaflet/index.d.ts
index a9ddc1b227..1d88365237 100644
--- a/types/proj4leaflet/index.d.ts
+++ b/types/proj4leaflet/index.d.ts
@@ -3,11 +3,12 @@
 // Definitions by: BendingBender <https://github.com/BendingBender>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-import * as proj4 from "proj4";
-import * as Leaflet from "leaflet";
+import * as geojson from 'geojson';
+import * as L from 'leaflet';
+import * as proj4 from 'proj4';
 
-declare global {
-  namespace L.Proj {
+declare module 'leaflet' {
+  namespace Proj {
     class CRS implements CRS {
       projection: Projection;
       transformation: Transformation;
@@ -38,13 +39,11 @@ declare global {
       wrapLatLng(latlng: LatLng | LatLngLiteral): LatLng;
     }
 
-    class GeoJSON extends Leaflet.GeoJSON {
-    }
+    class GeoJSON extends L.GeoJSON {}
 
-    const geoJson: (geojson?: GeoJSONGeoJsonObject, options?: GeoJSONOptions) => GeoJSON;
+    const geoJson: (geojson?: geojson.GeoJsonObject, options?: GeoJSONOptions) => GeoJSON;
 
-    class ImageOverlay extends Leaflet.ImageOverlay {
-    }
+    class ImageOverlay extends L.ImageOverlay {}
 
     const imageOverlay: (imageUrl: string, bounds: LatLngBoundsExpression, options?: ImageOverlayOptions) => ImageOverlay;
 
@@ -57,5 +56,3 @@ declare global {
     }
   }
 }
-
-export = L;
diff --git a/types/proj4leaflet/proj4leaflet-tests.ts b/types/proj4leaflet/proj4leaflet-tests.ts
index 1c7bb8a3eb..e061a4ca3a 100644
--- a/types/proj4leaflet/proj4leaflet-tests.ts
+++ b/types/proj4leaflet/proj4leaflet-tests.ts
@@ -1,4 +1,8 @@
-import * as proj4 from "proj4";
+import * as L from 'leaflet';
+import 'proj4leaflet';
+
+import * as proj4 from 'proj4';
+
 import LatLngBoundsExpression = L.LatLngBoundsExpression;
 
 const crs = new L.Proj.CRS('EPSG:2400',
diff --git a/types/react-leaflet/index.d.ts b/types/react-leaflet/index.d.ts
index 84269cf5bf..5fdc5831e9 100644
--- a/types/react-leaflet/index.d.ts
+++ b/types/react-leaflet/index.d.ts
@@ -13,31 +13,31 @@ import * as React from 'react';
 export type Children = React.ReactNode | React.ReactNode[];
 
 export interface MapEvents {
-    onclick?(event: Leaflet.MouseEvent): void;
-    ondblclick?(event: Leaflet.MouseEvent): void;
-    onmousedown?(event: Leaflet.MouseEvent): void;
-    onmouseup?(event: Leaflet.MouseEvent): void;
-    onmouseover?(event: Leaflet.MouseEvent): void;
-    onmouseout?(event: Leaflet.MouseEvent): void;
-    onmousemove?(event: Leaflet.MouseEvent): void;
-    oncontextmenu?(event: Leaflet.MouseEvent): void;
-    onfocus?(event: Leaflet.Event): void;
-    onblur?(event: Leaflet.Event): void;
-    onpreclick?(event: Leaflet.MouseEvent): void;
-    onload?(event: Leaflet.Event): void;
-    onunload?(event: Leaflet.Event): void;
-    onviewreset?(event: Leaflet.Event): void;
-    onmove?(event: Leaflet.Event): void;
-    onmovestart?(event: Leaflet.Event): void;
-    onmoveend?(event: Leaflet.Event): void;
-    ondragstart?(event: Leaflet.Event): void;
-    ondrag?(event: Leaflet.Event): void;
+    onclick?(event: Leaflet.LeafletMouseEvent): void;
+    ondblclick?(event: Leaflet.LeafletMouseEvent): void;
+    onmousedown?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseup?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseover?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseout?(event: Leaflet.LeafletMouseEvent): void;
+    onmousemove?(event: Leaflet.LeafletMouseEvent): void;
+    oncontextmenu?(event: Leaflet.LeafletMouseEvent): void;
+    onfocus?(event: Leaflet.LeafletEvent): void;
+    onblur?(event: Leaflet.LeafletEvent): void;
+    onpreclick?(event: Leaflet.LeafletMouseEvent): void;
+    onload?(event: Leaflet.LeafletEvent): void;
+    onunload?(event: Leaflet.LeafletEvent): void;
+    onviewreset?(event: Leaflet.LeafletEvent): void;
+    onmove?(event: Leaflet.LeafletEvent): void;
+    onmovestart?(event: Leaflet.LeafletEvent): void;
+    onmoveend?(event: Leaflet.LeafletEvent): void;
+    ondragstart?(event: Leaflet.LeafletEvent): void;
+    ondrag?(event: Leaflet.LeafletEvent): void;
     ondragend?(event: Leaflet.DragEndEvent): void;
-    onzoomstart?(event: Leaflet.Event): void;
-    onzoomend?(event: Leaflet.Event): void;
-    onzoomlevelschange?(event: Leaflet.Event): void;
+    onzoomstart?(event: Leaflet.LeafletEvent): void;
+    onzoomend?(event: Leaflet.LeafletEvent): void;
+    onzoomlevelschange?(event: Leaflet.LeafletEvent): void;
     onresize?(event: Leaflet.ResizeEvent): void;
-    onautopanstart?(event: Leaflet.Event): void;
+    onautopanstart?(event: Leaflet.LeafletEvent): void;
     onlayeradd?(event: Leaflet.LayerEvent): void;
     onlayerremove?(event: Leaflet.LayerEvent): void;
     onbaselayerchange?(event: Leaflet.LayersControlEvent): void;
@@ -50,25 +50,25 @@ export interface MapEvents {
 }
 
 export interface MarkerEvents {
-    onclick?(event: Leaflet.MouseEvent): void;
-    ondblclick?(event: Leaflet.MouseEvent): void;
-    onmousedown?(event: Leaflet.MouseEvent): void;
-    onmouseover?(event: Leaflet.MouseEvent): void;
-    onmouseout?(event: Leaflet.MouseEvent): void;
-    oncontextmenu?(event: Leaflet.MouseEvent): void;
-    ondragstart?(event: Leaflet.Event): void;
-    ondrag?(event: Leaflet.Event): void;
+    onclick?(event: Leaflet.LeafletMouseEvent): void;
+    ondblclick?(event: Leaflet.LeafletMouseEvent): void;
+    onmousedown?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseover?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseout?(event: Leaflet.LeafletMouseEvent): void;
+    oncontextmenu?(event: Leaflet.LeafletMouseEvent): void;
+    ondragstart?(event: Leaflet.LeafletEvent): void;
+    ondrag?(event: Leaflet.LeafletEvent): void;
     ondragend?(event: Leaflet.DragEndEvent): void;
-    onmove?(event: Leaflet.Event): void;
-    onadd?(event: Leaflet.Event): void;
-    onremove?(event: Leaflet.Event): void;
+    onmove?(event: Leaflet.LeafletEvent): void;
+    onadd?(event: Leaflet.LeafletEvent): void;
+    onremove?(event: Leaflet.LeafletEvent): void;
     onpopupopen?(event: Leaflet.PopupEvent): void;
     onpopupclose?(event: Leaflet.PopupEvent): void;
 }
 
 export interface TileLayerEvents {
-    onloading?(event: Leaflet.Event): void;
-    onload?(event: Leaflet.Event): void;
+    onloading?(event: Leaflet.LeafletEvent): void;
+    onload?(event: Leaflet.LeafletEvent): void;
     ontileloadstart?(event: Leaflet.TileEvent): void;
     ontileload?(event: Leaflet.TileEvent): void;
     ontileunload?(event: Leaflet.TileEvent): void;
@@ -76,24 +76,24 @@ export interface TileLayerEvents {
 }
 
 export interface PathEvents {
-    onclick?(event: Leaflet.MouseEvent): void;
-    ondblclick?(event: Leaflet.MouseEvent): void;
-    onmousedown?(event: Leaflet.MouseEvent): void;
-    onmouseover?(event: Leaflet.MouseEvent): void;
-    onmouseout?(event: Leaflet.MouseEvent): void;
-    oncontextmenu?(event: Leaflet.MouseEvent): void;
-    onadd?(event: Leaflet.Event): void;
-    onremove?(event: Leaflet.Event): void;
+    onclick?(event: Leaflet.LeafletMouseEvent): void;
+    ondblclick?(event: Leaflet.LeafletMouseEvent): void;
+    onmousedown?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseover?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseout?(event: Leaflet.LeafletMouseEvent): void;
+    oncontextmenu?(event: Leaflet.LeafletMouseEvent): void;
+    onadd?(event: Leaflet.LeafletEvent): void;
+    onremove?(event: Leaflet.LeafletEvent): void;
     onpopupopen?(event: Leaflet.PopupEvent): void;
     onpopupclose?(event: Leaflet.PopupEvent): void;
 }
 
 export interface FeatureGroupEvents {
-    onclick?(event: Leaflet.MouseEvent): void;
-    ondblclick?(event: Leaflet.MouseEvent): void;
-    onmouseover?(event: Leaflet.MouseEvent): void;
-    onmouseout?(event: Leaflet.MouseEvent): void;
-    oncontextmenu?(event: Leaflet.MouseEvent): void;
+    onclick?(event: Leaflet.LeafletMouseEvent): void;
+    ondblclick?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseover?(event: Leaflet.LeafletMouseEvent): void;
+    onmouseout?(event: Leaflet.LeafletMouseEvent): void;
+    oncontextmenu?(event: Leaflet.LeafletMouseEvent): void;
     onlayeradd?(event: Leaflet.LayerEvent): void;
     onlayerremove?(event: Leaflet.LayerEvent): void;
 }
diff --git a/types/react-leaflet/react-leaflet-tests.tsx b/types/react-leaflet/react-leaflet-tests.tsx
index 973586fece..c12b7d6617 100644
--- a/types/react-leaflet/react-leaflet-tests.tsx
+++ b/types/react-leaflet/react-leaflet-tests.tsx
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import * as ReactDOM from 'react-dom';
-import * as Leaflet from 'leaflet';
+import * as L from 'leaflet';
 import { Component, PropTypes } from 'react';
 import {
     Children,
@@ -32,7 +32,7 @@ const { BaseLayer, Overlay } = LayersControl;
 interface AnimateExampleState {
     animate: boolean;
     hasLocation: boolean;
-    latlng: Leaflet.LatLngExpression;
+    latlng: L.LatLngExpression;
 }
 
 export class AnimateExample extends Component<undefined, AnimateExampleState> {
@@ -45,7 +45,7 @@ export class AnimateExample extends Component<undefined, AnimateExampleState> {
         },
     };
 
-    handleClick = (e: Leaflet.MouseEvent) => {
+    handleClick = (e: L.LeafletMouseEvent) => {
         this.setState({
             latlng: e.latlng,
         });
@@ -96,17 +96,17 @@ export class AnimateExample extends Component<undefined, AnimateExampleState> {
 }
 
 // bounds.js
-const outer: Leaflet.LatLngBoundsLiteral = [
+const outer: L.LatLngBoundsLiteral = [
     [50.505, -29.09],
     [52.505, 29.09],
 ];
-const inner: Leaflet.LatLngBoundsLiteral = [
+const inner: L.LatLngBoundsLiteral = [
     [49.505, -2.09],
     [53.505, 2.09],
 ];
 
 interface BoundsExampleState {
-    bounds: Leaflet.LatLngBoundsLiteral;
+    bounds: L.LatLngBoundsLiteral;
 }
 
 export class BoundsExample extends Component<undefined, BoundsExampleState> {
@@ -147,7 +147,7 @@ export class BoundsExample extends Component<undefined, BoundsExampleState> {
 // custom-component.js
 interface MyPopupMarkerProps {
     children: Children;
-    position: Leaflet.LatLngExpression;
+    position: L.LatLngExpression;
 }
 
 interface MyMarker extends MyPopupMarkerProps {
@@ -187,7 +187,7 @@ export class CustomComponent extends Component<undefined, CustomComponentState>
     };
 
     render() {
-        const center: Leaflet.LatLngExpression = [this.state.lat, this.state.lng];
+        const center: L.LatLngExpression = [this.state.lat, this.state.lng];
 
         const markers: MyMarker[] = [
             { key: 'marker1', position: [51.5, -0.1], children: 'My first popup' },
@@ -212,7 +212,7 @@ export class MarkerWithDivIconExample extends Component<undefined, undefined> {
         return (
             <Map>
                 <Marker position={[0, 0]} icon={
-                    new Leaflet.DivIcon({})
+                    new L.DivIcon({})
                 } />
             </Map>
         );
@@ -221,8 +221,8 @@ export class MarkerWithDivIconExample extends Component<undefined, undefined> {
 
 // draggable-marker.js
 interface DraggableExampleState {
-    center: Leaflet.LatLngLiteral;
-    marker: Leaflet.LatLngLiteral;
+    center: L.LatLngLiteral;
+    marker: L.LatLngLiteral;
     zoom: number;
     draggable: boolean;
 }
@@ -256,8 +256,8 @@ export class DraggableExample extends Component<undefined, DraggableExampleState
     }
 
     render() {
-        const position: Leaflet.LatLngExpression = [this.state.center.lat, this.state.center.lng];
-        const markerPosition: Leaflet.LatLngExpression = [this.state.marker.lat, this.state.marker.lng];
+        const position: L.LatLngExpression = [this.state.center.lat, this.state.center.lng];
+        const markerPosition: L.LatLngExpression = [this.state.marker.lat, this.state.marker.lng];
 
         return (
             <Map center={position} zoom={this.state.zoom}>
@@ -285,7 +285,7 @@ export class DraggableExample extends Component<undefined, DraggableExampleState
 // events.js
 interface EventsExampleState {
     hasLocation: boolean;
-    latlng: Leaflet.LatLngLiteral;
+    latlng: L.LatLngLiteral;
 }
 
 export class EventsExample extends Component<undefined, EventsExampleState> {
@@ -301,7 +301,7 @@ export class EventsExample extends Component<undefined, EventsExampleState> {
         (this.refs.map as Map).leafletElement.locate();
     }
 
-    handleLocationFound = (e: Leaflet.LocationEvent) => {
+    handleLocationFound = (e: L.LocationEvent) => {
         this.setState({
             hasLocation: true,
             latlng: e.latlng,
@@ -339,8 +339,8 @@ export class EventsExample extends Component<undefined, EventsExampleState> {
 // layers-control.js
 export class LayersControlExample extends Component<undefined, undefined> {
     render() {
-        const center: Leaflet.LatLngExpression = [51.505, -0.09];
-        const rectangle: Leaflet.LatLngBoundsExpression = [
+        const center: L.LatLngExpression = [51.505, -0.09];
+        const rectangle: L.LatLngBoundsExpression = [
             [51.49, -0.08],
             [51.5, -0.06],
         ];
@@ -394,8 +394,8 @@ export class LayersControlExample extends Component<undefined, undefined> {
 // other-layers.js
 export class OtherLayersExample extends Component<undefined, undefined> {
     render() {
-        const center: Leaflet.LatLngExpression = [51.505, -0.09];
-        const rectangle: Leaflet.LatLngBoundsExpression = [
+        const center: L.LatLngExpression = [51.505, -0.09];
+        const rectangle: L.LatLngBoundsExpression = [
             [51.49, -0.08],
             [51.5, -0.06],
         ];
@@ -481,7 +481,7 @@ export class SimpleExample extends Component<undefined, SimpleExampleState> {
     };
 
     render() {
-        const position: Leaflet.LatLngExpression = [this.state.lat, this.state.lng];
+        const position: L.LatLngExpression = [this.state.lat, this.state.lng];
         return (
             <Map center={position} zoom={this.state.zoom}>
                 <TileLayer
@@ -513,14 +513,14 @@ export class TooltipExample extends Component<undefined, TooltipExampleState> {
     }
 
     render() {
-        const center: Leaflet.LatLngExpression = [51.505, -0.09];
+        const center: L.LatLngExpression = [51.505, -0.09];
 
-        const multiPolygon: Leaflet.LatLngExpression[][] = [
+        const multiPolygon: L.LatLngExpression[][] = [
             [[51.51, -0.12], [51.51, -0.13], [51.53, -0.13]],
             [[51.51, -0.05], [51.51, -0.07], [51.53, -0.07]],
         ];
 
-        const rectangle: Leaflet.LatLngBoundsExpression = [
+        const rectangle: L.LatLngBoundsExpression = [
             [51.49, -0.08],
             [51.5, -0.06],
         ];
@@ -576,31 +576,31 @@ export class TooltipExample extends Component<undefined, TooltipExampleState> {
 // vector-layers.js
 export class VectorLayersExample extends Component<undefined, undefined> {
     render() {
-        const center: Leaflet.LatLngExpression = [51.505, -0.09];
+        const center: L.LatLngExpression = [51.505, -0.09];
 
-        const polyline: Leaflet.LatLngExpression[] = [
+        const polyline: L.LatLngExpression[] = [
             [51.505, -0.09],
             [51.51, -0.1],
             [51.51, -0.12],
         ];
 
-        const multiPolyline: Leaflet.LatLngExpression[][] = [
+        const multiPolyline: L.LatLngExpression[][] = [
             [[51.5, -0.1], [51.5, -0.12], [51.52, -0.12]],
             [[51.5, -0.05], [51.5, -0.06], [51.52, -0.06]],
         ];
 
-        const polygon: Leaflet.LatLngExpression[] = [
+        const polygon: L.LatLngExpression[] = [
             [51.515, -0.09],
             [51.52, -0.1],
             [51.52, -0.12],
         ];
 
-        const multiPolygon: Leaflet.LatLngExpression[][] = [
+        const multiPolygon: L.LatLngExpression[][] = [
             [[51.51, -0.12], [51.51, -0.13], [51.53, -0.13]],
             [[51.51, -0.05], [51.51, -0.07], [51.53, -0.07]],
         ];
 
-        const rectangle: Leaflet.LatLngBoundsExpression = [
+        const rectangle: L.LatLngBoundsExpression = [
             [51.49, -0.08],
             [51.5, -0.06],
         ];
@@ -701,7 +701,7 @@ class CenterControl extends MapControl {  // note we're extending MapControl fro
     }
 }
 
-const mapControlCenter: Leaflet.LatLngExpression = [51.505, -0.09];
+const mapControlCenter: L.LatLngExpression = [51.505, -0.09];
 
 const CenterControlExample = () => (
     <Map center={mapControlCenter} zoom={13}>