// Type definitions for Leaflet.js 0.6.4 // Project: https://github.com/Leaflet/Leaflet // Definitions by: Vladimir Zotov // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module L { export interface AttributionOptions { /** * The position of the control (one of the map corners). See control positions. * Default value: 'bottomright'. */ position?: string; /** * The HTML text shown before the attributions. Pass false to disable. * Default value: 'Powered by Leaflet'. */ prefix?: string; } } declare module L { /** * Creates a Bounds object from two coordinates (usually top-left and bottom-right * corners). */ export function bounds(topLeft: Point, bottomRight: Point): Bounds; /** * Creates a Bounds object defined by the points it contains. */ export function bounds(points: Point[]): Bounds; export class Bounds { /** * Creates a Bounds object from two coordinates (usually top-left and bottom-right * corners). */ constructor(topLeft: Point, bottomRight: Point); /** * Creates a Bounds object defined by the points it contains. */ constructor(points: Point[]); /** * Extends the bounds to contain the given point. */ extend(point: Point): void; /** * Returns the center point of the bounds. */ getCenter(): Point; /** * Returns true if the rectangle contains the given one. */ contains(otherBounds: Bounds): boolean; /** * Returns true if the rectangle contains the given point. */ contains(point: Point): boolean; /** * Returns true if the rectangle intersects the given bounds. */ intersects(otherBounds: Bounds): boolean; /** * Returns true if the bounds are properly initialized. */ isValid(): boolean; /** * Returns the size of the given bounds. */ getSize(): Point; /** * The top left corner of the rectangle. */ min: Point; /** * The bottom right corner of the rectangle. */ max: Point; } } declare module L { export class Browser { /** * true for all Internet Explorer versions. */ static ie: boolean; /** * true for Internet Explorer 6. */ static ie6: boolean; /** * true for Internet Explorer 6. */ static ie7: boolean; /** * true for webkit-based browsers like Chrome and Safari (including mobile * versions). */ static webkit: boolean; /** * true for webkit-based browsers that support CSS 3D transformations. */ static webkit3d: boolean; /** * true for Android mobile browser. */ static android: boolean; /** * true for old Android stock browsers (2 and 3). */ static android23: boolean; /** * true for modern mobile browsers (including iOS Safari and different Android * browsers). */ static mobile: boolean; /** * true for mobile webkit-based browsers. */ static mobileWebkit: boolean; /** * true for mobile Opera. */ static mobileOpera: boolean; /** * true for all browsers on touch devices. */ static touch: boolean; /** * true for browsers with Microsoft touch model (e.g. IE10). */ static msTouch: boolean; /** * true for devices with Retina screens. */ static retina: boolean; } } declare module L { /** * Instantiates a circle object given a geographical point, a radius in meters * and optionally an options object. */ function circle(latlng: LatLng, radius: number, options?: PathOptions): Circle; export class Circle extends Path { /** * Instantiates a circle object given a geographical point, a radius in meters * and optionally an options object. */ constructor(latlng: LatLng, radius: number, options?: PathOptions); /** * Returns the current geographical position of the circle. */ getLatLng(): LatLng; /** * Returns the current radius of a circle. Units are in meters. */ getRadius(): number; /** * Sets the position of a circle to a new location. */ setLatLng(latlng: LatLng): Circle; /** * Sets the radius of a circle. Units are in meters. */ setRadius(radius: number): Circle; /** * Returns a GeoJSON representation of the circle (GeoJSON Point Feature). */ toGeoJSON(): any; } } declare module L { /** * Instantiates a circle marker given a geographical point and optionally * an options object. The default radius is 10 and can be altered by passing a * "radius" member in the path options object. */ function circleMarker(latlng: LatLng, options?: PathOptions): CircleMarker; export class CircleMarker extends Circle { /** * Instantiates a circle marker given a geographical point and optionally * an options object. The default radius is 10 and can be altered by passing a * "radius" member in the path options object. */ constructor(latlng: LatLng, options?: PathOptions); /** * Sets the position of a circle marker to a new location. */ setLatLng(latlng: LatLng): CircleMarker; /** * Sets the radius of a circle marker. Units are in pixels. */ setRadius(radius: number): CircleMarker; /** * Returns a GeoJSON representation of the circle marker (GeoJSON Point Feature). */ toGeoJSON(): any; } } declare module L { export interface ClassExtendOptions { /** * options is a special property that unlike other objects that you pass * to extend will be merged with the parent one instead of overriding it * completely, which makes managing configuration of objects and default * values convenient. */ options?: any; /** * includes is a special class property that merges all specified objects * into the class (such objects are called mixins). A good example of this * is L.Mixin.Events that event-related methods like on, off and fire * to the class. */ includes?: any; /** * statics is just a convenience property that injects specified object * properties as the static properties of the class, useful for defining * constants. */ static?: any; } /** * L.Class powers the OOP facilities of Leaflet and is used to create * almost all of the Leaflet classes documented. */ export class Class { /** * You use L.Class.extend to define new classes, but you can use the * same method on any class to inherit from it. */ static extend(options: ClassExtendOptions): any; /** * You can also use the following shortcut when you just need to make * one additional method call. */ static addInitHook(methodName: string, ...args: any[]): void; } } declare module L { export class Control extends Class implements IControl { /** * Creates a control with the given options. */ constructor(options?: ControlOptions); /** * Sets the position of the control. See control positions. */ setPosition(position: string): Control; /** * Returns the current position of the control. */ getPosition(): string; /** * Adds the control to the map. */ addTo(map: Map): Control; /** * Removes the control from the map. */ removeFrom(map: Map): Control; /** * Returns the HTML container of the control. */ getContainer(): HTMLElement; // IControl members /** * Should contain code that creates all the neccessary DOM elements for the * control, adds listeners on relevant map events, and returns the element * containing the control. Called on map.addControl(control) or control.addTo(map). */ onAdd(map: Map): HTMLElement; /** * Optional, should contain all clean up code (e.g. removes control's event * listeners). Called on map.removeControl(control) or control.removeFrom(map). * The control's DOM container is removed automatically. */ onRemove(map: Map): void; } module Control { export class Zoom extends L.Control { /** * Creates a zoom control. */ constructor(options?: ZoomOptions); } export class Attribution extends L.Control { /** * Creates an attribution control. */ constructor(options?: AttributionOptions); /** * Sets the text before the attributions. */ setPrefix(prefix: string): Attribution; /** * Adds an attribution text (e.g. 'Vector data © CloudMade'). */ addAttribution(text: string): Attribution; /** * Removes an attribution text. */ removeAttribution(text: string): Attribution; } export class Layers extends L.Control implements IEventPowered { /** * Creates an attribution control with the given layers. Base layers will be * switched with radio buttons, while overlays will be switched with checkboxes. */ constructor(baseLayers?: any, overlays?: any, options?: LayersOptions); /** * Adds a base layer (radio button entry) with the given name to the control. */ addBaseLayer(layer: ILayer, name: string): Layers; /** * Adds an overlay (checkbox entry) with the given name to the control. */ addOverlay(layer: ILayer, name: string): Layers; /** * Remove the given layer from the control. */ removeLayer(layer: ILayer): Layers; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Layers; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Layers; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): Layers; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): Layers; on(type: string, fn: (e: LeafletEvent) => void, context?: any): Layers; once(type: string, fn: (e: LeafletEvent) => void, context?: any): Layers; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): Layers; fire(type: string, data?: any): Layers; addEventListener(eventMap: any, context?: any): Layers; removeEventListener(eventMap?: any, context?: any): Layers; clearAllEventListeners(): Layers; on(eventMap: any, context?: any): Layers; off(eventMap?: any, context?: any): Layers; } export class Scale extends L.Control { /** * Creates an scale control with the given options. */ constructor(options?: ScaleOptions); } } export class control { /** * Creates a control with the given options. */ function (options?: ControlOptions): Control; /** * Creates a zoom control. */ static zoom(options?: ZoomOptions): L.Control.Zoom; /** * Creates an attribution control. */ static attribution(options?: AttributionOptions): L.Control.Attribution; /** * Creates an attribution control with the given layers. Base layers will be * switched with radio buttons, while overlays will be switched with checkboxes. */ static layers(baseLayers?: any, overlays?: any, options?: LayersOptions): L.Control.Layers; /** * Creates an scale control with the given options. */ static scale(options?: ScaleOptions): L.Control.Scale; } } declare module L { export interface ControlOptions { /** * The initial position of the control (one of the map corners). See control * positions. * Default value: 'topright'. */ position: string; } } declare module L { export class CRS { /** * The most common CRS for online maps, used by almost all free and commercial * tile providers. Uses Spherical Mercator projection. Set in by default in * Map's crs option. */ static EPSG3857: ICRS; /** * A common CRS among GIS enthusiasts. Uses simple Equirectangular projection. */ static EPSG4326: ICRS; /** * Rarely used by some commercial tile providers. Uses Elliptical Mercator * projection. */ static EPSG3395: ICRS; /** * A simple CRS that maps longitude and latitude into x and y directly. May be * used for maps of flat surfaces (e.g. game maps). Note that the y axis should * still be inverted (going from bottom to top). */ static Simple: ICRS; } } declare module L { /** * Creates a div icon instance with the given options. */ function divIcon(options: DivIconOptions): DivIcon; export class DivIcon extends Icon { /** * Creates a div icon instance with the given options. */ constructor(options: DivIconOptions); } } declare module L { export interface DivIconOptions { /** * Size of the icon in pixels. Can be also set through CSS. */ iconSize?: Point; /** * The coordinates of the "tip" of the icon (relative to its top left corner). * The icon will be aligned so that this point is at the marker's geographical * location. Centered by default if size is specified, also can be set in CSS * with negative margins. */ iconAnchor?: Point; /** * A custom class name to assign to the icon. * * Default value: 'leaflet-div-icon'. */ className?: string; /** * A custom HTML code to put inside the div element. * * Default value: ''. */ html?: string; } } declare module L { export class DomEvent { /** * Adds a listener fn to the element's DOM event of the specified type. this keyword * inside the listener will point to context, or to the element if not specified. */ static addListener(el: HTMLElement, type: string, fn: (e: Event) => void, context?: any): DomEvent; /** * Removes an event listener from the element. */ static removeListener(el: HTMLElement, type: string, fn: (e: Event) => void): DomEvent; /** * Stop the given event from propagation to parent elements. Used inside the * listener functions: * L.DomEvent.addListener(div, 'click', function * (e) { * L.DomEvent.stopPropagation(e); * }); */ static stopPropagation(e: Event): DomEvent; /** * Prevents the default action of the event from happening (such as following * a link in the href of the a element, or doing a POST request with page reload * when form is submitted). Use it inside listener functions. */ static preventDefault(e: Event): DomEvent; /** * Does stopPropagation and preventDefault at the same time. */ static stop(e: Event): DomEvent; /** * Adds stopPropagation to the element's 'click', 'doubleclick', 'mousedown' * and 'touchstart' events. */ static disableClickPropagation(el: HTMLElement): DomEvent; /** * Gets normalized mouse position from a DOM event relative to the container * or to the whole page if not specified. */ static getMousePosition(e: Event, container?: HTMLElement): Point; /** * Gets normalized wheel delta from a mousewheel DOM event. */ static getWheelDelta(e: Event): number; } } declare module L { export class DomUtil { /** * Returns an element with the given id if a string was passed, or just returns * the element if it was passed directly. */ static get(id: string): HTMLElement; /** * Returns the value for a certain style attribute on an element, including * computed values or values set through CSS. */ static getStyle(el: HTMLElement, style: string): string; /** * Returns the offset to the viewport for the requested element. */ static getViewportOffset(el: HTMLElement): Point; /** * Creates an element with tagName, sets the className, and optionally appends * it to container element. */ static create(tagName: string, className: string, container?: HTMLElement): HTMLElement; /** * Makes sure text cannot be selected, for example during dragging. */ static disableTextSelection(): void; /** * Makes text selection possible again. */ static enableTextSelection(): void; /** * Returns true if the element class attribute contains name. */ static hasClass(el: HTMLElement, name: string): boolean; /** * Adds name to the element's class attribute. */ static addClass(el: HTMLElement, name: string): void; /** * Removes name from the element's class attribute. */ static removeClass(el: HTMLElement, name: string): void; /** * Set the opacity of an element (including old IE support). Value must be from * 0 to 1. */ static setOpacity(el: HTMLElement, value: number): void; /** * Goes through the array of style names and returns the first name that is a valid * style name for an element. If no such name is found, it returns false. Useful * for vendor-prefixed styles like transform. */ static testProp(props: string[]): any; /** * Returns a CSS transform string to move an element by the offset provided in * the given point. Uses 3D translate on WebKit for hardware-accelerated transforms * and 2D on other browsers. */ static getTranslateString(point: Point): string; /** * Returns a CSS transform string to scale an element (with the given scale origin). */ static getScaleString(scale: number, origin: Point): string; /** * Sets the position of an element to coordinates specified by point, using * CSS translate or top/left positioning depending on the browser (used by * Leaflet internally to position its layers). Forces top/left positioning * if disable3D is true. */ static setPosition(el: HTMLElement, point: Point, disable3D?: boolean): void; /** * Returns the coordinates of an element previously positioned with setPosition. */ static getPosition(el: HTMLElement): Point; /** * Vendor-prefixed transition style name (e.g. 'webkitTransition' for WebKit). */ static TRANSITION: string; /** * Vendor-prefixed transform style name. */ static TRANSFORM: string; } } declare module L { /** * Creates a Draggable object for moving the given element when you start dragging * the dragHandle element (equals the element itself by default). */ function draggable(element: HTMLElement, dragHandle?: HTMLElement): Draggable; export class Draggable extends Class implements IEventPowered { /** * Creates a Draggable object for moving the given element when you start dragging * the dragHandle element (equals the element itself by default). */ constructor(element: HTMLElement, dragHandle?: HTMLElement); /** * Enables the dragging ability. */ enable(): void; /** * Disables the dragging ability. */ disable(): void; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Draggable; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Draggable; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): Draggable; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): Draggable; on(type: string, fn: (e: LeafletEvent) => void, context?: any): Draggable; once(type: string, fn: (e: LeafletEvent) => void, context?: any): Draggable; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): Draggable; fire(type: string, data?: any): Draggable; addEventListener(eventMap: any, context?: any): Draggable; removeEventListener(eventMap?: any, context?: any): Draggable; clearAllEventListeners(): Draggable; on(eventMap: any, context?: any): Draggable; off(eventMap?: any, context?: any): Draggable; } } declare module L { /** * Create a layer group, optionally given an initial set of layers. */ function featureGroup(layers?: ILayer[]): FeatureGroup; export class FeatureGroup extends LayerGroup implements ILayer, IEventPowered { /** * Create a layer group, optionally given an initial set of layers. */ constructor(layers?: ILayer[]); /** * Binds a popup with a particular HTML content to a click on any layer from the * group that has a bindPopup method. */ bindPopup(htmlContent: string, options?: PopupOptions): FeatureGroup; /** * Returns the LatLngBounds of the Feature Group (created from bounds and coordinates * of its children). */ getBounds(): LatLngBounds; /** * Sets the given path options to each layer of the group that has a setStyle method. */ setStyle(style: PathOptions): FeatureGroup; /** * Brings the layer group to the top of all other layers. */ bringToFront(): FeatureGroup; /** * Brings the layer group to the bottom of all other layers. */ bringToBack(): FeatureGroup; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): FeatureGroup; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): FeatureGroup; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): FeatureGroup; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): FeatureGroup; on(type: string, fn: (e: LeafletEvent) => void, context?: any): FeatureGroup; once(type: string, fn: (e: LeafletEvent) => void, context?: any): FeatureGroup; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): FeatureGroup; fire(type: string, data?: any): FeatureGroup; addEventListener(eventMap: any, context?: any): FeatureGroup; removeEventListener(eventMap?: any, context?: any): FeatureGroup; clearAllEventListeners(): FeatureGroup; on(eventMap: any, context?: any): FeatureGroup; off(eventMap?: any, context?: any): FeatureGroup; } } declare module L { export interface FitBoundsOptions extends ZoomPanOptions { /** * Sets the amount of padding in the top left corner of a map container that * shouldn't be accounted for when setting the view to fit bounds. Useful if * you have some control overlays on the map like a sidebar and you don't * want them to obscure objects you're zooming to. * * Default value: [0, 0]. */ paddingTopLeft?: Point; /** * The same for bottom right corner of the map. * * Default value: [0, 0]. */ paddingBottomRight?: Point; /** * Equivalent of setting both top left and bottom right padding to the same value. * * Default value: [0, 0]. */ padding?: Point; } } declare module L { /** * 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?: any, options?: GeoJSONOptions): GeoJSON; export class GeoJSON extends FeatureGroup { /** * 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. */ constructor(geojson?: any, options?: GeoJSONOptions); /** * Adds a GeoJSON object to the layer. */ addData(data: any): boolean; /** * Changes styles of GeoJSON vector layers with the given style function. */ setStyle(style: (featureData: any) => any): GeoJSON; /** * Resets the the given vector layer's style to the original GeoJSON style, * useful for resetting style after hover events. */ resetStyle(layer: Path): GeoJSON; /** * Creates a layer from a given GeoJSON feature. */ static geometryToLayer(featureData: GeoJSON, pointToLayer?: (featureData: any, latlng: LatLng) => ILayer): ILayer; /** * Creates a LatLng object from an array of 2 numbers (latitude, longitude) * used in GeoJSON for points. If reverse is set to true, the numbers will be interpreted * as (longitude, latitude). */ static coordsToLatlng(coords: number[], reverse?: boolean): LatLng; /** * Creates a multidimensional array of LatLng objects 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). If reverse is set to * true, the numbers will be interpreted as (longitude, latitude). */ static coordsToLatlngs(coords: number[], levelsDeep?: number, reverse?: boolean): LatLng[]; } } declare module L { export interface GeoJSONOptions { /** * Function that will be used for creating layers for GeoJSON points (if not * specified, simple markers will be created). */ pointToLayer?: (featureData: any, latlng: LatLng) => ILayer; /** * Function that will be used to get style options for vector layers created * for GeoJSON features. */ style?: (featureData: any) => any; /** * Function that will be called on each created feature layer. Useful for attaching * events and popups to features. */ onEachFeature?: (featureData: any, layer: ILayer) => void; /** * Function that will be used to decide whether to show a feature or not. */ filter?: (featureData: any, layer: ILayer) => boolean; /** * Function that will be used for converting GeoJSON coordinates to LatLng points * (if not specified, coords will be assumed to be WGS84 � standard[longitude, latitude] * values in degrees). */ coordsToLatLng?: (coords: any[]) => LatLng[]; } } declare module L { /** * Creates an icon instance with the given options. */ function icon(options: IconOptions): Icon; export class Icon extends Class { /** * Creates an icon instance with the given options. */ constructor(options: IconOptions); } module Icon { /** * L.Icon.Default extends L.Icon and is the blue icon Leaflet uses * for markers by default. */ export class Default extends Icon { /** * Creates a default icon instance with the given options. */ constructor(options?: IconOptions); static imagePath: string; } } } declare module L { export interface IconOptions { /** * (required) The URL to the icon image (absolute or relative to your script * path). */ iconUrl?: string; /** * The URL to a retina sized version of the icon image (absolute or relative to * your script path). Used for Retina screen devices. */ iconRetinaUrl?: string; /** * Size of the icon image in pixels. */ iconSize?: Point; /** * The coordinates of the "tip" of the icon (relative to its top left corner). * The icon will be aligned so that this point is at the marker's geographical * location. Centered by default if size is specified, also can be set in CSS * with negative margins. */ iconAnchor?: Point; /** * The URL to the icon shadow image. If not specified, no shadow image will be * created. */ shadowUrl?: string; /** * The URL to the retina sized version of the icon shadow image. If not specified, * no shadow image will be created. Used for Retina screen devices. */ shadowRetinaUrl?: string; /** * Size of the shadow image in pixels. */ shadowSize?: Point; /** * The coordinates of the "tip" of the shadow (relative to its top left corner) * (the same as iconAnchor if not specified). */ shadowAnchor?: Point; /** * The coordinates of the point from which popups will "open", relative to the * icon anchor. */ popupAnchor?: Point; /** * A custom class name to assign to both icon and shadow images. Empty by default. */ className?: string; } } declare module L { export interface IControl { /** * Should contain code that creates all the neccessary DOM elements for the * control, adds listeners on relevant map events, and returns the element * containing the control. Called on map.addControl(control) or control.addTo(map). */ onAdd(map: Map): HTMLElement; /** * Optional, should contain all clean up code (e.g. removes control's event * listeners). Called on map.removeControl(control) or control.removeFrom(map). * The control's DOM container is removed automatically. */ onRemove(map: Map): void; } } declare module L { export interface ICRS { /** * Projection that this CRS uses. */ projection: IProjection; /** * Transformation that this CRS uses to turn projected coordinates into screen * coordinates for a particular tile service. */ transformation: Transformation; /** * Standard code name of the CRS passed into WMS services (e.g. 'EPSG:3857'). */ code: string; /** * Projects geographical coordinates on a given zoom into pixel coordinates. */ latLngToPoint(latlng: LatLng, zoom: number): Point; /** * The inverse of latLngToPoint. Projects pixel coordinates on a given zoom * into geographical coordinates. */ pointToLatLng(point: Point, zoom: number): LatLng; /** * Projects geographical coordinates into coordinates in units accepted * for this CRS (e.g. meters for EPSG:3857, for passing it to WMS services). */ project(latlng: LatLng): Point; /** * Returns the scale used when transforming projected coordinates into pixel * coordinates for a particular zoom. For example, it returns 256 * 2^zoom for * Mercator-based CRS. */ scale(zoom: number): number; } } declare module L { export interface IEventPowered { /** * 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: (e: LeafletEvent) => void, context?: any): T; /** * The same as above except the listener will only get fired once and then removed. */ addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): T; /** * Adds a set of type/listener pairs, e.g. {click: onClick, mousemove: onMouseMove} */ addEventListener(eventMap: any, context?: any): T; /** * Removes a previously added listener function. If no function is specified, * it will remove all the listeners of that particular event from the object. */ removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): T; /** * Removes a set of type/listener pairs. */ removeEventListener(eventMap?: any, context?: any): T; /** * Returns true if a particular event type has some listeners attached to it. */ hasEventListeners(type: string): boolean; /** * Fires an event of the specified type. You can optionally provide an data object * — the first argument of the listener function will contain its properties. */ fireEvent(type: string, data?: any): T; /** * Removes all listeners to all events on the object. */ clearAllEventListeners(): T; /** * Alias to addEventListener. */ on(type: string, fn: (e: LeafletEvent) => void, context?: any): T; /** * Alias to addEventListener. */ on(eventMap: any, context?: any): T; /** * Alias to addOneTimeEventListener. */ once(type: string, fn: (e: LeafletEvent) => void, context?: any): T; /** * Alias to removeEventListener. */ off(type: string, fn?: (e: LeafletEvent) => void, context?: any): T; /** * Alias to removeEventListener. */ off(eventMap?: any, context?: any): T; /** * Alias to fireEvent. */ fire(type: string, data?: any): T; } } declare module L { export interface IHandler { /** * Enables the handler. */ enable(): void; /** * Disables the handler. */ disable(): void; /** * Returns true if the handler is enabled. */ enabled(): boolean; } } declare module L { export interface ILayer { /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; } } declare module L { /** * Instantiates an image overlay object given the URL of the image and the geographical * bounds it is tied to. */ function imageOverlay(imageUrl: string, bounds: LatLngBounds, options?: ImageOverlayOptions): ImageOverlay; export class ImageOverlay extends Class implements ILayer { /** * Instantiates an image overlay object given the URL of the image and the geographical * bounds it is tied to. */ constructor(imageUrl: string, bounds: LatLngBounds, options?: ImageOverlayOptions); /** * Adds the overlay to the map. */ addTo(map: Map): ImageOverlay; /** * Sets the opacity of the overlay. */ setOpacity(opacity: number): ImageOverlay; /** * Brings the layer to the top of all overlays. */ bringToFront(): ImageOverlay; /** * Brings the layer to the bottom of all overlays. */ bringToBack(): ImageOverlay; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; } } declare module L { export interface ImageOverlayOptions { /** * The opacity of the image overlay. */ opacity?: number; } } declare module L { export interface IProjection { /** * Projects geographical coordinates into a 2D point. */ project(latlng: LatLng): Point; /** * The inverse of project. Projects a 2D point into geographical location. */ unproject(point: Point): LatLng; } } declare module L { /** * A constant that represents the Leaflet version in use. */ export var version: string; /** * This method restores the L global variale to the original value it had * before Leaflet inclusion, and returns the real Leaflet namespace. */ export function noConflict(): typeof L; } declare module L { /** * Creates an object representing a geographical point with the given latitude * and longitude. */ function latLng(latitude: number, longitude: number): LatLng; /** * Creates an object representing a geographical point with the given latitude * and longitude. */ function latLng(coords: number[]): LatLng; export class LatLng { /** * Creates an object representing a geographical point with the given latitude * and longitude. */ constructor(latitude: number, longitude: number); /** * Creates an object representing a geographical point with the given latitude * and longitude. */ constructor(coords: number[]); /** * Returns the distance (in meters) to the given LatLng calculated using the * Haversine formula. See description on wikipedia */ distanceTo(otherLatlng: LatLng): number; /** * Returns true if the given LatLng point is at the same position (within a small * margin of error). */ equals(otherLatlng: LatLng): boolean; /** * Returns a string representation of the point (for debugging purposes). */ toString(): string; /** * Returns a new LatLng object with the longitude wrapped around left and right * boundaries (-180 to 180 by default). */ wrap(left: number, right: number): LatLng; /** * Latitude in degrees. */ lat: number; /** * Longitude in degrees. */ lng: number; /** * A multiplier for converting degrees into radians. * * Value: Math.PI / 180. */ static DEG_TO_RAD: number; /** * A multiplier for converting radians into degrees. * * Value: 180 / Math.PI. */ static RAD_TO_DEG: number; /** * Max margin of error for the equality check. * * Value: 1.0E-9. */ static MAX_MARGIN: number; } } declare module L { /** * Creates a LatLngBounds object by defining south-west and north-east corners * of the rectangle. */ function latLngBounds(southWest: LatLng, northEast: LatLng): LatLngBounds; /** * Creates a LatLngBounds object defined by the geographical points it contains. * Very useful for zooming the map to fit a particular set of locations with fitBounds. */ function latLngBounds(latlngs: LatLng[]): LatLngBounds; export class LatLngBounds { /** * Creates a LatLngBounds object by defining south-west and north-east corners * of the rectangle. */ constructor(southWest: LatLng, northEast: LatLng); /** * Creates a LatLngBounds object defined by the geographical points it contains. * Very useful for zooming the map to fit a particular set of locations with fitBounds. */ constructor(latlngs: LatLng[]); /** * Extends the bounds to contain the given point. */ extend(latlng: LatLng): LatLngBounds; /** * Extends the bounds to contain the given bounds. */ extend(latlng: LatLngBounds): LatLngBounds; /** * Returns the south-west point of the bounds. */ getSouthWest(): LatLng; /** * Returns the north-east point of the bounds. */ getNorthEast(): LatLng; /** * Returns the north-west point of the bounds. */ getNorthWest(): LatLng; /** * Returns the south-east point of the bounds. */ getSouthEast(): LatLng; /** * Returns the center point of the bounds. */ getCenter(): LatLng; /** * Returns true if the rectangle contains the given one. */ contains(otherBounds: LatLngBounds): boolean; /** * Returns true if the rectangle contains the given point. */ contains(latlng: LatLng): boolean; /** * Returns true if the rectangle intersects the given bounds. */ intersects(otherBounds: LatLngBounds): boolean; /** * Returns true if the rectangle is equivalent (within a small margin of error) * to the given bounds. */ equals(otherBounds: LatLngBounds): boolean; /** * Returns a string with bounding box coordinates in a 'southwest_lng,southwest_lat,northeast_lng,northeast_lat' * format. Useful for sending requests to web services that return geo data. */ toBBoxString(): string; /** * Returns bigger bounds created by extending the current bounds by a given * percentage in each direction. */ pad(bufferRatio: number): LatLngBounds; /** * Returns true if the bounds are properly initialized. */ isValid(): boolean; } } declare module L { /** * Create a layer group, optionally given an initial set of layers. */ function layerGroup(layers?: ILayer[]): LayerGroup; export class LayerGroup extends Class implements ILayer { /** * Create a layer group, optionally given an initial set of layers. */ constructor(layers?: ILayer[]); /** * Adds the group of layers to the map. */ addTo(map: Map): LayerGroup; /** * Adds a given layer to the group. */ addLayer(layer: ILayer): LayerGroup; /** * Removes a given layer from the group. */ removeLayer(layer: ILayer): LayerGroup; /** * Removes a given layer of the given id from the group. */ removeLayer(id: string): LayerGroup; /** * Returns true if the given layer is currently added to the group. */ hasLayer(layer: ILayer): boolean; /** * Returns the layer with the given id. */ getLayer(id: string): ILayer; /** * Returns an array of all the layers added to the group. */ getLayers(): ILayer[]; /** * Removes all the layers from the group. */ clearLayers(): LayerGroup; /** * Iterates over the layers of the group, optionally specifying context of * the iterator function. */ eachLayer(fn: (layer: ILayer) => void, context?: any): LayerGroup; /** * Returns a GeoJSON representation of the layer group (GeoJSON FeatureCollection). */ toGeoJSON(): any; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; } } declare module L { export interface LayersOptions { /** * The position of the control (one of the map corners). See control positions. * * Default value: 'topright'. */ position?: string; /** * If true, the control will be collapsed into an icon and expanded on mouse hover * or touch. * * Default value: true. */ collapsed?: boolean; /** * If true, the control will assign zIndexes in increasing order to all of its * layers so that the order is preserved when switching them on/off. * * Default value: true. */ autoZIndex?: boolean; } } declare module L { export interface LeafletErrorEvent extends LeafletEvent { /** * Error message. */ message: string; /** * Error code (if applicable). */ code: number; } } declare module L { export interface LeafletEvent { /** * The event type (e.g. 'click'). */ type: string; /** * The object that fired the event. */ target: any; } } declare module L { export interface LeafletGeoJSONEvent extends LeafletEvent { /** * The layer for the GeoJSON feature that is being added to the map. */ layer: ILayer; /** * GeoJSON properties of the feature. */ properties: any; /** * GeoJSON geometry type of the feature. */ geometryType: string; /** * GeoJSON ID of the feature (if present). */ id: string; } } declare module L { export interface LeafletLayerEvent extends LeafletEvent { /** * The layer that was added or removed. */ layer: ILayer; } } declare module L { export interface LeafletLocationEvent extends LeafletEvent { /** * Detected geographical location of the user. */ latlng: LatLng; /** * Geographical bounds of the area user is located in (with respect to the accuracy * of location). */ bounds: LatLngBounds; /** * Accuracy of location in meters. */ accuracy: number; /** * Height of the position above the WGS84 ellipsoid in meters. */ altitude: number; /** * Accuracy of altitude in meters. */ altitudeAccuracy: number; /** * The direction of travel in degrees counting clockwise from true North. */ heading: number; /** * Current velocity in meters per second. */ speed: number; /** * The time when the position was acquired. */ timestamp: number; } } declare module L { export interface LeafletMouseEvent extends LeafletEvent { /** * The geographical point where the mouse event occured. */ latlng: LatLng; /** * Pixel coordinates of the point where the mouse event occured relative to * the map layer. */ layerPoint: Point; /** * Pixel coordinates of the point where the mouse event occured relative to * the map сontainer. */ containerPoint: Point; /** * The original DOM mouse event fired by the browser. */ originalEvent: MouseEvent; } } declare module L { export interface LeafletPopupEvent extends LeafletEvent { /** * The popup that was opened or closed. */ popup: Popup; } } declare module L { export interface LeafletResizeEvent extends LeafletEvent { /** * The old size before resize event. */ oldSize: Point; /** * The new size after the resize event. */ newSize: Point; } } declare module L { export interface LeafletTileEvent extends LeafletEvent { /** * The tile element (image). */ tile: HTMLElement; /** * The source URL of the tile. */ url: string; } } declare module L { export class LineUtil { /** * Dramatically reduces the number of points in a polyline while retaining * its shape and returns a new array of simplified points. Used for a huge performance * boost when processing/displaying Leaflet polylines for each zoom level * and also reducing visual noise. tolerance affects the amount of simplification * (lesser value means higher quality but slower and with more points). Also * released as a separated micro-library Simplify.js. */ static simplify(points: Point[], tolerance: number): Point[]; /** * Returns the distance between point p and segment p1 to p2. */ static pointToSegmentDistance(p: Point, p1: Point, p2: Point): number; /** * Returns the closest point from a point p on a segment p1 to p2. */ static closestPointOnSegment(p: Point, p1: Point, p2: Point): number; /** * Clips the segment a to b by rectangular bounds (modifying the segment points * directly!). Used by Leaflet to only show polyline points that are on the screen * or near, increasing performance. */ static clipSegment(a: Point, b: Point, bounds: Bounds): void; } } declare module L { export interface LocateOptions { /** * If true, starts continous watching of location changes (instead of detecting * it once) using W3C watchPosition method. You can later stop watching using * map.stopLocate() method. * * Default value: false. */ watch?: boolean; /** * If true, automatically sets the map view to the user location with respect * to detection accuracy, or to world view if geolocation failed. * * Default value: false. */ setView?: boolean; /** * The maximum zoom for automatic view setting when using `setView` option. * * Default value: Infinity. */ maxZoom?: number; /** * Number of millisecond to wait for a response from geolocation before firing * a locationerror event. * * Default value: 10000. */ timeout?: number; /** * Maximum age of detected location. If less than this amount of milliseconds * passed since last geolocation response, locate will return a cached location. * * Default value: 0. */ maximumAge?: number; /** * Enables high accuracy, see description in the W3C spec. * * Default value: false. */ enableHighAccuracy?: boolean; } } declare module L { /** * Instantiates a map object given a div element and optionally an * object literal with map options described below. */ function map(id: HTMLElement, options?: MapOptions): Map; /** * Instantiates a map object given a div element id and optionally an * object literal with map options described below. */ function map(id: string, options?: MapOptions): Map; export class Map extends Class implements IEventPowered { /** * Instantiates a map object given a div element and optionally an * object literal with map options described below. * * @constructor */ constructor(id: HTMLElement, options?: MapOptions); /** * Instantiates a map object given a div element id and optionally an * object literal with map options described below. * * @constructor */ constructor(id: string, options?: MapOptions); // Methods for Modifying Map State /** * Sets the view of the map (geographical center and zoom) with the given * animation options. */ setView(center: LatLng, zoom: number, options?: ZoomPanOptions): Map; /** * Sets the zoom of the map. */ setZoom(zoom: number, options?: ZoomOptions): Map; /** * Increases the zoom of the map by delta (1 by default). */ zoomIn(delta?: number, options?: ZoomOptions): Map; /** * Decreases the zoom of the map by delta (1 by default). */ zoomOut(delta?: number, options?: ZoomOptions): Map; /** * Zooms the map while keeping a specified point on the map stationary * (e.g. used internally for scroll zoom and double-click zoom). */ setZoomAround(latlng: LatLng, zoom: number, options?: ZoomOptions): Map; /** * Sets a map view that contains the given geographical bounds with the maximum * zoom level possible. */ fitBounds(bounds: LatLngBounds, options?: FitBoundsOptions): Map; /** * Sets a map view that mostly contains the whole world with the maximum zoom * level possible. */ fitWorld(options?: FitBoundsOptions): Map; /** * Pans the map to a given center. Makes an animated pan if new center is not more * than one screen away from the current one. */ panTo(latlng: LatLng, options?: PanOptions): Map; /** * Pans the map to the closest view that would lie inside the given bounds (if * it's not already). */ panInsideBounds(bounds: LatLngBounds): Map; /** * Pans the map by a given number of pixels (animated). */ panBy(point: Point, options?: PanOptions): Map; /** * Checks if the map container size changed and updates the map if so — call it * after you've changed the map size dynamically, also animating pan by default. * If options.pan is false, panning will not occur. */ invalidateSize(options: ZoomPanOptions): Map; /** * Checks if the map container size changed and updates the map if so — call it * after you've changed the map size dynamically, also animating pan by default. */ invalidateSize(animate: boolean): Map; /** * Restricts the map view to the given bounds (see map maxBounds option), * passing the given animation options through to `setView`, if required. */ setMaxBounds(bounds: LatLngBounds, options?: ZoomPanOptions): Map; /** * Tries to locate the user using Geolocation API, firing locationfound event * with location data on success or locationerror event on failure, and optionally * sets the map view to the user location with respect to detection accuracy * (or to the world view if geolocation failed). See Locate options for more * details. */ locate(options?: LocateOptions): Map; /** * Stops watching location previously initiated by map.locate({watch: true}) * and aborts resetting the map view if map.locate was called with {setView: true}. */ stopLocate(): Map; /** * Destroys the map and clears all related event listeners. */ remove(): Map; // Methods for Getting Map State /** * Returns the geographical center of the map view. */ getCenter(): LatLng; /** * Returns the current zoom of the map view. */ getZoom(): number; /** * Returns the minimum zoom level of the map. */ getMinZoom(): number; /** * Returns the maximum zoom level of the map. */ getMaxZoom(): number; /** * Returns the LatLngBounds of the current map view. */ getBounds(): LatLngBounds; /** * Returns the maximum zoom level on which the given bounds fit to the map view * in its entirety. If inside (optional) is set to true, the method instead returns * the minimum zoom level on which the map view fits into the given bounds in its * entirety. */ getBoundsZoom(bounds: LatLngBounds, inside?: boolean): number; /** * Returns the current size of the map container. */ getSize(): Point; /** * Returns the bounds of the current map view in projected pixel coordinates * (sometimes useful in layer and overlay implementations). */ getPixelBounds(): Bounds; /** * Returns the projected pixel coordinates of the top left point of the map layer * (useful in custom layer and overlay implementations). */ getPixelOrigin(): Point; // Methods for Layers and Controls /** * Adds the given layer to the map. If optional insertAtTheBottom is set to true, * the layer is inserted under all others (useful when switching base tile layers). */ addLayer(layer: ILayer, insertAtTheBottom?: boolean): Map; /** * Removes the given layer from the map. */ removeLayer(layer: ILayer): Map; /** * Returns true if the given layer is currently added to the map. */ hasLayer(layer: ILayer): boolean; /** * Opens the specified popup while closing the previously opened (to make sure * only one is opened at one time for usability). */ openPopup(popup: Popup): Map; /** * Creates a popup with the specified options and opens it in the given point * on a map. */ openPopup(html: string, latlng: LatLng, options?: PopupOptions): Map; /** * Creates a popup with the specified options and opens it in the given point * on a map. */ openPopup(el: HTMLElement, latlng: LatLng, options?: PopupOptions): Map; /** * Closes the popup previously opened with openPopup (or the given one). */ closePopup(): Map; /** * Adds the given control to the map. */ addControl(control: IControl): Map; /** * Removes the given control from the map. */ removeControl(control: IControl): Map; // Conversion Methods /** * Returns the map layer point that corresponds to the given geographical coordinates * (useful for placing overlays on the map). */ latLngToLayerPoint(latlng: LatLng): Point; /** * Returns the geographical coordinates of a given map layer point. */ layerPointToLatLng(point: Point): LatLng; /** * Converts the point relative to the map container to a point relative to the * map layer. */ containerPointToLayerPoint(point: Point): Point; /** * Converts the point relative to the map layer to a point relative to the map * container. */ layerPointToContainerPoint(point: Point): Point; /** * Returns the map container point that corresponds to the given geographical * coordinates. */ latLngToContainerPoint(latlng: LatLng): Point; /** * Returns the geographical coordinates of a given map container point. */ containerPointToLatLng(point: Point): LatLng; /** * Projects the given geographical coordinates to absolute pixel coordinates * for the given zoom level (current zoom level by default). */ project(latlng: LatLng, zoom?: number): Point; /** * Projects the given absolute pixel coordinates to geographical coordinates * for the given zoom level (current zoom level by default). */ unproject(point: Point, zoom?: number): LatLng; /** * Returns the pixel coordinates of a mouse click (relative to the top left corner * of the map) given its event object. */ mouseEventToContainerPoint(event: LeafletMouseEvent): Point; /** * Returns the pixel coordinates of a mouse click relative to the map layer given * its event object. */ mouseEventToLayerPoint(event: LeafletMouseEvent): Point; /** * Returns the geographical coordinates of the point the mouse clicked on given * the click's event object. */ mouseEventToLatLng(event: LeafletMouseEvent): LatLng; // Other Methods /** * Returns the container element of the map. */ getContainer(): HTMLElement; /** * Returns an object with different map panes (to render overlays in). */ getPanes(): MapPanes; // REVIEW: Should we make it more flexible declaring parameter 'fn' as Function? /** * Runs the given callback when the map gets initialized with a place and zoom, * or immediately if it happened already, optionally passing a function context. */ whenReady(fn: (map: Map) => void, context?: any): Map; // Properties /** * Map dragging handler (by both mouse and touch). */ dragging: IHandler; /** * Touch zoom handler. */ touchZoom: IHandler; /** * Double click zoom handler. */ doubleClickZoom: IHandler; /** * Scroll wheel zoom handler. */ scrollWheelZoom: IHandler; /** * Box (shift-drag with mouse) zoom handler. */ boxZoom: IHandler; /** * Keyboard navigation handler. */ keyboard: IHandler; /** * Mobile touch hacks (quick tap and touch hold) handler. */ tap: IHandler; /** * Zoom control. */ zoomControl: Control.Zoom; /** * Attribution control. */ attributionControl: Control.Attribution; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Map; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Map; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): Map; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): Map; on(type: string, fn: (e: LeafletEvent) => void, context?: any): Map; once(type: string, fn: (e: LeafletEvent) => void, context?: any): Map; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): Map; fire(type: string, data?: any): Map;addEventListener(eventMap: any, context?: any): Map; removeEventListener(eventMap?: any, context?: any): Map; clearAllEventListeners(): Map; on(eventMap: any, context?: any): Map; off(eventMap?: any, context?: any): Map; } } declare module L { export interface MapOptions { // Map State Options /** * Initial geographical center of the map. */ center?: LatLng; /** * Initial map zoom. */ zoom?: number; /** * Layers that will be added to the map initially. */ layers?: ILayer[]; /** * Minimum zoom level of the map. Overrides any minZoom set on map layers. */ minZoom?: number; /** * Maximum zoom level of the map. This overrides any maxZoom set on map layers. */ maxZoom?: number; /** * When this option is set, the map restricts the view to the given geographical * bounds, bouncing the user back when he tries to pan outside the view, and also * not allowing to zoom out to a view that's larger than the given bounds (depending * on the map size). To set the restriction dynamically, use setMaxBounds method */ maxBounds?: LatLngBounds; /** * Coordinate Reference System to use. Don't change this if you're not sure * what it means. * * Default value: L.CRS.EPSG3857. */ crs?: ICRS; // Interaction Options /** * Whether the map be draggable with mouse/touch or not. * * Default value: true. */ dragging?: boolean; /** * Whether the map can be zoomed by touch-dragging with two fingers. * * Default value: true. */ touchZoom?: boolean; /** * Whether the map can be zoomed by using the mouse wheel. * * Default value: true. */ scrollWheelZoom?: boolean; /** * Whether the map can be zoomed in by double clicking on it. * * Default value: true. */ doubleClickZoom?: boolean; /** * Whether the map can be zoomed to a rectangular area specified by dragging * the mouse while pressing shift. * * Default value: true. */ boxZoom?: boolean; /** * Enables mobile hacks for supporting instant taps (fixing 200ms click delay * on iOS/Android) and touch holds (fired as contextmenu events). * * Default value: true. */ tap?: boolean; /** * The max number of pixels a user can shift his finger during touch for it * to be considered a valid tap. * * Default value: 15. */ tapTolerance?: number; /** * Whether the map automatically handles browser window resize to update itself. * * Default value: true. */ trackResize?: boolean; /** * With this option enabled, the map tracks when you pan to another "copy" of * the world and seamlessly jumps to the original one so that all overlays like * markers and vector layers are still visible. * * Default value: false. */ worldCopyJump?: boolean; /** * Set it to false if you don't want popups to close when user clicks the map. * * Default value: true. */ closePopupOnClick?: boolean; // Keyboard Navigation Options /** * Makes the map focusable and allows users to navigate the map with keyboard * arrows and +/- keys. * * Default value: true. */ keyboard?: boolean; /** * Amount of pixels to pan when pressing an arrow key. * * Default value: 80. */ keyboardPanOffset?: number; /** * Number of zoom levels to change when pressing + or - key. * * Default value: 1. */ keyboardZoomOffset?: number; // Panning Inertia Options /** * If enabled, panning of the map will have an inertia effect where the map builds * momentum while dragging and continues moving in the same direction for some * time. Feels especially nice on touch devices. * * Default value: true. */ inertia?: boolean; /** * The rate with which the inertial movement slows down, in pixels/second2. * * Default value: 3000. */ inertiaDeceleration?: number; /** * Max speed of the inertial movement, in pixels/second. * * Default value: 1500. */ inertiaMaxSpeed?: number; /** * Amount of milliseconds that should pass between stopping the movement and * releasing the mouse or touch to prevent inertial movement. * * Default value: 32 for touch devices and 14 for the rest. */ inertiaThreshold?: number; // Control options /** * Whether the zoom control is added to the map by default. * * Default value: true. */ zoomControl?: boolean; /** * Whether the attribution control is added to the map by default. * * Default value: true. */ attributionControl?: boolean; // Animation options /** * Whether the tile fade animation is enabled. By default it's enabled in all * browsers that support CSS3 Transitions except Android. */ fadeAnimation?: boolean; /** * Whether the tile zoom animation is enabled. By default it's enabled in all * browsers that support CSS3 Transitions except Android. */ zoomAnimation?: boolean; /** * Won't animate zoom if the zoom difference exceeds this value. * * Default value: 4. */ zoomAnimationThreshold?: number; /** * Whether markers animate their zoom with the zoom animation, if disabled * they will disappear for the length of the animation. By default it's enabled * in all browsers that support CSS3 Transitions except Android. */ markerZoomAnimation?: boolean; } } declare module L { export interface MapPanes { /** * Pane that contains all other map panes. */ mapPane: HTMLElement; /** * Pane for tile layers. */ tilePane: HTMLElement; /** * Pane that contains all the panes except tile pane. */ objectsPane: HTMLElement; /** * Pane for overlay shadows (e.g. marker shadows). */ shadowPane: HTMLElement; /** * Pane for overlays like polylines and polygons. */ overlayPane: HTMLElement; /** * Pane for marker icons. */ markerPane: HTMLElement; /** * Pane for popups. */ popupPane: HTMLElement; } } declare module L { /** * Instantiates a Marker object given a geographical point and optionally * an options object. */ function marker(latlng: LatLng, options?: MarkerOptions): Marker; export class Marker extends Class implements ILayer, IEventPowered { /** * Instantiates a Marker object given a geographical point and optionally * an options object. */ constructor(latlng: LatLng, options?: MarkerOptions); /** * Adds the marker to the map. */ addTo(map: Map): Marker; /** * Returns the current geographical position of the marker. */ getLatLng(): LatLng; /** * Changes the marker position to the given point. */ setLatLng(latlng: LatLng): Marker; /** * Changes the marker icon. */ setIcon(icon: Icon): Marker; /** * Changes the zIndex offset of the marker. */ setZIndexOffset(offset: number): Marker; /** * Changes the opacity of the marker. */ setOpacity(opacity: number): Marker; /** * Updates the marker position, useful if coordinates of its latLng object * were changed directly. */ update(): Marker; /** * Binds a popup with a particular HTML content to a click on this marker. You * can also open the bound popup with the Marker openPopup method. */ bindPopup(html: string, options?: PopupOptions): Marker; /** * Binds a popup with a particular HTML content to a click on this marker. You * can also open the bound popup with the Marker openPopup method. */ bindPopup(el: HTMLElement, options?: PopupOptions): Marker; /** * Binds a popup with a particular HTML content to a click on this marker. You * can also open the bound popup with the Marker openPopup method. */ bindPopup(popup: Popup, options?: PopupOptions): Marker; /** * Unbinds the popup previously bound to the marker with bindPopup. */ unbindPopup(): Marker; /** * Opens the popup previously bound by the bindPopup method. */ openPopup(): Marker; /** * Closes the bound popup of the marker if it's opened. */ closePopup(): Marker; /** * Toggles the popup previously bound by the bindPopup method. */ togglePopup(): Marker; /** * Sets an HTML content of the popup of this marker. */ setPopupContent(html: string, options?: PopupOptions): Marker; /** * Sets an HTML content of the popup of this marker. */ setPopupContent(el: HTMLElement, options?: PopupOptions): Marker; /** * Returns a GeoJSON representation of the marker (GeoJSON Point Feature). */ toGeoJSON(popup: Popup, options?: PopupOptions): any; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Marker; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Marker; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): Marker; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): Marker; on(type: string, fn: (e: LeafletEvent) => void, context?: any): Marker; once(type: string, fn: (e: LeafletEvent) => void, context?: any): Marker; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): Marker; fire(type: string, data?: any): Marker; addEventListener(eventMap: any, context?: any): Marker; removeEventListener(eventMap?: any, context?: any): Marker; clearAllEventListeners(): Marker; on(eventMap: any, context?: any): Marker; off(eventMap?: any, context?: any): Marker; } } declare module L { export interface MarkerOptions { /** * Icon class to use for rendering the marker. See Icon documentation for details * on how to customize the marker icon. * * Default value: new L.Icon.Default(). */ icon?: Icon; /** * If false, the marker will not emit mouse events and will act as a part of the * underlying map. * * Default value: true. */ clickable?: boolean; /** * Whether the marker is draggable with mouse/touch or not. * * Default value: false. */ draggable?: boolean; /** * Whether the marker can be tabbed to with a keyboard and clicked by pressing enter. * * Default value: true. */ keyboard?: boolean; /** * Text for the browser tooltip that appear on marker hover (no tooltip by default). * * Default value: ''. */ title?: string; /** * By default, marker images zIndex is set automatically based on its latitude. * You this option if you want to put the marker on top of all others (or below), * specifying a high value like 1000 (or high negative value, respectively). * * Default value: 0. */ zIndexOffset?: number; /** * The opacity of the marker. * * Default value: 1.0. */ opacity?: number; /** * If true, the marker will get on top of others when you hover the mouse over it. * * Default value: false. */ riseOnHover?: boolean; /** * The z-index offset used for the riseOnHover feature. * * Default value: 250. */ riseOffset?: number; } } declare module L { /** * Instantiates a multi-polyline object given an array of latlngs arrays (one * for each individual polygon) and optionally an options object (the same * as for MultiPolyline). */ function multiPolygon(latlngs: LatLng[][], options?: PolylineOptions): MultiPolygon; export class MultiPolygon extends FeatureGroup { /** * Instantiates a multi-polyline object given an array of latlngs arrays (one * for each individual polygon) and optionally an options object (the same * as for MultiPolyline). */ constructor(latlngs: LatLng[][], options?: PolylineOptions); /** * Replace all polygons and their paths with the given array of arrays * of geographical points. */ setLatLngs(latlngs: LatLng[][]): MultiPolygon; /** * Returns an array of arrays of geographical points in each polygon. */ getLatLngs(): LatLng[][]; /** * Returns a GeoJSON representation of the multipolygon (GeoJSON MultiPolygon Feature). */ toGeoJSON(): any; } } declare module L { /** * Instantiates a multi-polyline object given an array of arrays of geographical * points (one for each individual polyline) and optionally an options object. */ function multiPolyline(latlngs: LatLng[][], options?: PolylineOptions): MultiPolyline; export class MultiPolyline extends FeatureGroup { /** * Instantiates a multi-polyline object given an array of arrays of geographical * points (one for each individual polyline) and optionally an options object. */ constructor(latlngs: LatLng[][], options?: PolylineOptions); /** * Replace all polygons and their paths with the given array of arrays * of geographical points. */ setLatLngs(latlngs: LatLng[][]): MultiPolyline; /** * Returns an array of arrays of geographical points in each polygon. */ getLatLngs(): LatLng[][]; /** * Returns a GeoJSON representation of the multipolyline (GeoJSON MultiLineString Feature). */ toGeoJSON(): any; } } declare module L { export interface PanOptions { /** * If true, panning will always be animated if possible. If false, it will not * animate panning, either resetting the map view if panning more than a screen * away, or just setting a new offset for the map pane (except for `panBy` * which always does the latter). */ animate?: boolean; /** * Duration of animated panning. * * Default value: 0.25. */ duration?: number; /** * The curvature factor of panning animation easing (third parameter of the Cubic * Bezier curve). 1.0 means linear animation, the less the more bowed the curve. * * Default value: 0.25. */ easeLinearity?: number; /** * If true, panning won't fire movestart event on start (used internally for panning inertia). * * Default value: false. */ noMoveStart?: boolean; } } declare module L { export class Path extends Class implements ILayer, IEventPowered { /** * Adds the layer to the map. */ addTo(map: Map): Path; /** * Binds a popup with a particular HTML content to a click on this path. */ bindPopup(html: string, options?: PopupOptions): Path; /** * Binds a popup with a particular HTML content to a click on this path. */ bindPopup(el: HTMLElement, options?: PopupOptions): Path; /** * Binds a popup with a particular HTML content to a click on this path. */ bindPopup(popup: Popup, options?: PopupOptions): Path; /** * Unbinds the popup previously bound to the path with bindPopup. */ unbindPopup(): Path; /** * Opens the popup previously bound by the bindPopup method in the given point, * or in one of the path's points if not specified. */ openPopup(latlng?: LatLng): Path; /** * Closes the path's bound popup if it is opened. */ closePopup(): Path; /** * Changes the appearance of a Path based on the options in the Path options object. */ setStyle(object: PathOptions): Path; /** * Returns the LatLngBounds of the path. */ getBounds(): LatLngBounds; /** * Brings the layer to the top of all path layers. */ bringToFront(): Path; /** * Brings the layer to the bottom of all path layers. */ bringToBack(): Path; /** * Redraws the layer. Sometimes useful after you changed the coordinates that * the path uses. */ redraw(): Path; /** * True if SVG is used for vector rendering (true for most modern browsers). */ static SVG: boolean; /** * True if VML is used for vector rendering (IE 6-8). */ static VML: boolean; /** * True if Canvas is used for vector rendering (Android 2). You can also force * this by setting global variable L_PREFER_CANVAS to true before the Leaflet * include on your page — sometimes it can increase performance dramatically * when rendering thousands of circle markers, but currently suffers from * a bug that causes removing such layers to be extremely slow. */ static CANVAS: boolean; /** * How much to extend the clip area around the map view (relative to its size, * e.g. 0.5 is half the screen in each direction). Smaller values mean that you * will see clipped ends of paths while you're dragging the map, and bigger values * decrease drawing performance. */ static CLIP_PADDING: number; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Path; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): Path; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): Path; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): Path; on(type: string, fn: (e: LeafletEvent) => void, context?: any): Path; once(type: string, fn: (e: LeafletEvent) => void, context?: any): Path; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): Path; fire(type: string, data?: any): Path; addEventListener(eventMap: any, context?: any): Path; removeEventListener(eventMap?: any, context?: any): Path; clearAllEventListeners(): Path; on(eventMap: any, context?: any): Path; off(eventMap?: any, context?: any): Path; } } declare module L { export interface PathOptions { /** * Whether to draw stroke along the path. Set it to false to disable borders on * polygons or circles. * * Default value: true. */ stroke?: boolean; /** * Stroke color. * * Default value: '#03f'. */ color?: string; /** * Stroke width in pixels. * * Default value: 5. */ weight?: number; /** * Stroke opacity. * * Default value: 0.5. */ opacity?: number; /** * Whether to fill the path with color. Set it to false to disable filling on polygons * or circles. */ fill?: boolean; /** * Fill color. * * Default value: same as color. */ fillColor?: string; /** * Fill opacity. * * Default value: 0.2. */ fillOpacity?: number; /** * A string that defines the stroke dash pattern. Doesn't work on canvas-powered * layers (e.g. Android 2). */ dashArray?: string; /** * If false, the vector will not emit mouse events and will act as a part of the * underlying map. * * Default value: true. */ clickable?: boolean; /** * Sets the pointer-events attribute on the path if SVG backend is used. */ pointerEvents?: boolean; } } declare module L { /** * Creates a Point object with the given x and y coordinates. If optional round * is set to true, rounds the x and y values. */ function point(x: number, y: number, round?: boolean): Point; export class Point { /** * Creates a Point object with the given x and y coordinates. If optional round * is set to true, rounds the x and y values. */ constructor(x: number, y: number, round?: boolean); /** * Returns the result of addition of the current and the given points. */ add(otherPoint: Point): Point; /** * Returns the result of subtraction of the given point from the current. */ subtract(otherPoint: Point): Point; /** * Returns the result of multiplication of the current point by the given number. */ multiplyBy(number: number): Point; /** * Returns the result of division of the current point by the given number. If * optional round is set to true, returns a rounded result. */ divideBy(number: number, round?: boolean): Point; /** * Returns the distance between the current and the given points. */ distanceTo(otherPoint: Point): number; /** * Returns a copy of the current point. */ clone(): Point; /** * Returns a copy of the current point with rounded coordinates. */ round(): Point; /** * Returns true if the given point has the same coordinates. */ equals(otherPoint: Point): boolean; /** * Returns a string representation of the point for debugging purposes. */ toString(): string; /** * The x coordinate. */ x: number; /** * The y coordinate. */ y: number; } } declare module L { /** * Instantiates a polygon object given an array of geographical points and * optionally an options object (the same as for Polyline). You can also create * a polygon with holes by passing an array of arrays of latlngs, with the first * latlngs array representing the exterior ring while the remaining represent * the holes inside. */ function polygon(latlngs: LatLng[], options?: PolylineOptions): Polygon; export class Polygon extends Polyline { /** * Instantiates a polygon object given an array of geographical points and * optionally an options object (the same as for Polyline). You can also create * a polygon with holes by passing an array of arrays of latlngs, with the first * latlngs array representing the exterior ring while the remaining represent * the holes inside. */ constructor(latlngs: LatLng[], options?: PolylineOptions); } } declare module L { /** * Instantiates a polyline object given an array of geographical points and * optionally an options object. */ function polyline(latlngs: LatLng[], options?: PolylineOptions): Polyline; export class Polyline extends Path { /** * Instantiates a polyline object given an array of geographical points and * optionally an options object. */ constructor(latlngs: LatLng[], options?: PolylineOptions); /** * Adds a given point to the polyline. */ addLatLng(latlng: LatLng): Polyline; /** * Replaces all the points in the polyline with the given array of geographical * points. */ setLatLngs(latlngs: LatLng[]): Polyline; /** * Returns an array of the points in the path. */ getLatLngs(): LatLng[]; /** * Allows adding, removing or replacing points in the polyline. Syntax is the * same as in Array#splice. Returns the array of removed points (if any). */ spliceLatLngs(index: number, pointsToRemove: number, ...latlngs: LatLng[]): LatLng[]; /** * Returns the LatLngBounds of the polyline. */ getBounds(): LatLngBounds; /** * Returns a GeoJSON representation of the polyline (GeoJSON LineString Feature). */ toGeoJSON(): any; } } declare module L { export interface PolylineOptions { /** * How much to simplify the polyline on each zoom level. More means better performance * and smoother look, and less means more accurate representation. * * Default value: 1.0. */ smoothFactor?: number; /** * Disabled polyline clipping. * * Default value: false. */ noClip?: boolean; } } declare module L { export class PolyUtil { /** * Clips the polygon geometry defined by the given points by rectangular bounds. * Used by Leaflet to only show polygon points that are on the screen or near, * increasing performance. Note that polygon points needs different algorithm * for clipping than polyline, so there's a seperate method for it. */ static clipPolygon(points: Point[], bounds: Bounds): Point[]; } } declare module L { /** * Instantiates a Popup object given an optional options object that describes * its appearance and location and an optional object that is used to tag the * popup with a reference to the source object to which it refers. */ function popup(options?: PopupOptions, source?: any): Popup; export class Popup extends Class implements ILayer { /** * Instantiates a Popup object given an optional options object that describes * its appearance and location and an optional object that is used to tag the * popup with a reference to the source object to which it refers. */ constructor(options?: PopupOptions, source?: any); /** * Adds the popup to the map. */ addTo(map: Map): Popup; /** * Adds the popup to the map and closes the previous one. The same as map.openPopup(popup). */ openOn(map: Map): Popup; /** * Sets the geographical point where the popup will open. */ setLatLng(latlng: LatLng): Popup; /** * Sets the HTML content of the popup. */ setContent(html: string): Popup; /** * Sets the HTML content of the popup. */ setContent(el: HTMLElement): Popup; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; } } declare module L { export interface PopupOptions { /** * Max width of the popup. * * Default value: 300. */ maxWidth?: number; /** * Min width of the popup. * * Default value: 50. */ minWidth?: number; /** * If set, creates a scrollable container of the given height inside a popup * if its content exceeds it. */ maxHeight?: number; /** * Set it to false if you don't want the map to do panning animation to fit the opened * popup. * * Default value: true. */ autoPan?: boolean; /** * Controls the presense of a close button in the popup. * * Default value: true. */ closeButton?: boolean; /** * The offset of the popup position. Useful to control the anchor of the popup * when opening it on some overlays. * * Default value: new Point(0, 6). */ offset?: Point; /** * The margin between the popup and the edges of the map view after autopanning * was performed. * * Default value: new Point(5, 5). */ autoPanPadding?: Point; /** * Whether to animate the popup on zoom. Disable it if you have problems with * Flash content inside popups. * * Default value: true. */ zoomAnimation?: boolean; /** * Set it to false if you want to override the default behavior of the popup * closing when user clicks the map (set globally by the Map closePopupOnClick * option). */ closeOnClick?: boolean; } } declare module L { export class PosAnimation extends Class implements IEventPowered { /** * Creates a PosAnimation object. */ constructor(); /** * Run an animation of a given element to a new position, optionally setting * duration in seconds (0.25 by default) and easing linearity factor (3rd argument * of the cubic bezier curve, 0.5 by default) */ run(element: HTMLElement, newPos: Point, duration?: number, easeLinearity?: number): PosAnimation; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): PosAnimation; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): PosAnimation; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): PosAnimation; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): PosAnimation; on(type: string, fn: (e: LeafletEvent) => void, context?: any): PosAnimation; once(type: string, fn: (e: LeafletEvent) => void, context?: any): PosAnimation; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): PosAnimation; fire(type: string, data?: any): PosAnimation; addEventListener(eventMap: any, context?: any): PosAnimation; removeEventListener(eventMap?: any, context?: any): PosAnimation; clearAllEventListeners(): PosAnimation; on(eventMap: any, context?: any): PosAnimation; off(eventMap?: any, context?: any): PosAnimation; } } declare module L { export class Projection { /** * Spherical Mercator projection — the most common projection for online maps, * used by almost all free and commercial tile providers. Assumes that Earth * is a sphere. Used by the EPSG:3857 CRS. */ static SphericalMercator: IProjection; /** * Elliptical Mercator projection — more complex than Spherical Mercator. * Takes into account that Earth is a geoid, not a perfect sphere. Used by the * EPSG:3395 CRS. */ static Mercator: IProjection; /** * Equirectangular, or Plate Carree projection — the most simple projection, * mostly used by GIS enthusiasts. Directly maps x as longitude, and y as latitude. * Also suitable for flat worlds, e.g. game maps. Used by the EPSG:3395 and Simple * CRS. */ static LonLat: IProjection; } } declare module L { /** * Instantiates a rectangle object with the given geographical bounds and * optionally an options object. */ function rectangle(bounds: LatLngBounds, options?: PathOptions): Rectangle; export class Rectangle extends Polygon { /** * Instantiates a rectangle object with the given geographical bounds and * optionally an options object. */ constructor(bounds: LatLngBounds, options?: PathOptions); /** * Redraws the rectangle with the passed bounds. */ setBounds(bounds: LatLngBounds): Rectangle; } } declare module L { export interface ScaleOptions { /** * The position of the control (one of the map corners). See control positions. * Default value: 'bottomleft'. */ position?: string; /** * Maximum width of the control in pixels. The width is set dynamically to show * round values (e.g. 100, 200, 500). * Default value: 100. */ maxWidth?: number; /** * Whether to show the metric scale line (m/km). * Default value: true. */ metric?: boolean; /** * Whether to show the imperial scale line (mi/ft). * Default value: true. */ imperial?: boolean; /** * If true, the control is updated on moveend, otherwise it's always up-to-date * (updated on move). * Default value: false. */ updateWhenIdle?: boolean; } } declare module L { export class TileLayer implements ILayer, IEventPowered { /** * Instantiates a tile layer object given a URL template and optionally an options * object. */ constructor(urlTemplate: string, options?: TileLayerOptions); /** * Adds the layer to the map. */ addTo(map: Map): TileLayer; /** * Brings the tile layer to the top of all tile layers. */ bringToFront(): TileLayer; /** * Brings the tile layer to the bottom of all tile layers. */ bringToBack(): TileLayer; /** * Changes the opacity of the tile layer. */ setOpacity(opacity: number): TileLayer; /** * Sets the zIndex of the tile layer. */ setZIndex(zIndex: number): TileLayer; /** * Causes the layer to clear all the tiles and request them again. */ redraw(): TileLayer; /** * Updates the layer's URL template and redraws it. */ setUrl(urlTemplate: string): TileLayer; /** * Returns the HTML element that contains the tiles for this layer. */ getContainer(): HTMLElement; //////////// //////////// /** * Should contain code that creates DOM elements for the overlay, adds them * to map panes where they should belong and puts listeners on relevant map events. * Called on map.addLayer(layer). */ onAdd(map: Map): void; /** * Should contain all clean up code that removes the overlay's elements from * the DOM and removes listeners previously added in onAdd. Called on map.removeLayer(layer). */ onRemove(map: Map): void; //////////////// //////////////// addEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): TileLayer; addOneTimeEventListener(type: string, fn: (e: LeafletEvent) => void, context?: any): TileLayer; removeEventListener(type: string, fn?: (e: LeafletEvent) => void, context?: any): TileLayer; hasEventListeners(type: string): boolean; fireEvent(type: string, data?: any): TileLayer; on(type: string, fn: (e: LeafletEvent) => void, context?: any): TileLayer; once(type: string, fn: (e: LeafletEvent) => void, context?: any): TileLayer; off(type: string, fn?: (e: LeafletEvent) => void, context?: any): TileLayer; fire(type: string, data?: any): TileLayer; addEventListener(eventMap: any, context?: any): TileLayer; removeEventListener(eventMap?: any, context?: any): TileLayer; clearAllEventListeners(): TileLayer; on(eventMap: any, context?: any): TileLayer; off(eventMap?: any, context?: any): TileLayer; } module TileLayer { export class WMS { /** * Instantiates a WMS tile layer object given a base URL of the WMS service and * a WMS parameters/options object. */ constructor(baseUrl: string, options: WMSOptions); /** * Merges an object with the new parameters and re-requests tiles on the current * screen (unless noRedraw was set to true). */ setParams(params: WMS, noRedraw?: boolean): WMS; } export class Canvas { /** * Instantiates a Canvas tile layer object given an options object (optionally). */ constructor(options?: TileLayerOptions); /** * You need to define this method after creating the instance to draw tiles; * canvas is the actual canvas tile on which you can draw, tilePoint represents * the tile numbers, and zoom is the current zoom. */ drawTile(canvas: HTMLCanvasElement, tilePoint: Point, zoom: number): Canvas; /** * Calling redraw will cause the drawTile method to be called for all tiles. * May be used for updating dynamic content drawn on the Canvas */ redraw(): Canvas; } } export class tileLayer { /** * Instantiates a tile layer object given a URL template and optionally an options * object. */ function (urlTemplate: string, options?: TileLayerOptions): TileLayer; /** * Instantiates a WMS tile layer object given a base URL of the WMS service and * a WMS parameters/options object. */ static wms(baseUrl: string, options: WMSOptions): L.TileLayer.WMS; /** * Instantiates a Canvas tile layer object given an options object (optionally). */ static canvas(options?: TileLayerOptions): L.TileLayer.Canvas; } } declare module L { export interface TileLayerOptions { /** * Minimum zoom number. * * Default value: 0. */ minZoom?: number; /** * Maximum zoom number. * * Default value: 18. */ maxZoom?: number; /** * Tile size (width and height in pixels, assuming tiles are square). * * Default value: 256. */ tileSize?: number; /** * Subdomains of the tile service. Can be passed in the form of one string (where * each letter is a subdomain name) or an array of strings. * * Default value: 'abc'. */ subdomains?: string[]; /** * URL to the tile image to show in place of the tile that failed to load. * * Default value: ''. */ errorTileUrl?: string; /** * e.g. "© CloudMade" — the string used by the attribution control, describes * the layer data. * * Default value: ''. */ attribution?: string; /** * If true, inverses Y axis numbering for tiles (turn this on for TMS services). * * Default value: false. */ tms?: boolean; /** * If set to true, the tile coordinates won't be wrapped by world width (-180 * to 180 longitude) or clamped to lie within world height (-90 to 90). Use this * if you use Leaflet for maps that don't reflect the real world (e.g. game, indoor * or photo maps). * * Default value: false. */ continuousWorld?: boolean; /** * If set to true, the tiles just won't load outside the world width (-180 to 180 * longitude) instead of repeating. * * Default value: false. */ noWrap?: boolean; /** * The zoom number used in tile URLs will be offset with this value. * * Default value: 0. */ zoomOffset?: number; /** * If set to true, the zoom number used in tile URLs will be reversed (maxZoom * - zoom instead of zoom) * * Default value: false. */ zoomReverse?: boolean; /** * The opacity of the tile layer. * * Default value: 1.0. */ opacity?: number; /** * The explicit zIndex of the tile layer. Not set by default. */ zIndex?: number; /** * If true, all the tiles that are not visible after panning are removed (for * better performance). true by default on mobile WebKit, otherwise false. */ unloadInvisibleTiles?: boolean; /** * If false, new tiles are loaded during panning, otherwise only after it (for * better performance). true by default on mobile WebKit, otherwise false. */ updateWhenIdle?: boolean; /** * If true and user is on a retina display, it will request four tiles of half the * specified size and a bigger zoom level in place of one to utilize the high resolution. * * Default value: false. */ detectRetina?: boolean; /** * If true, all the tiles that are not visible after panning are placed in a reuse * queue from which they will be fetched when new tiles become visible (as opposed * to dynamically creating new ones). This will in theory keep memory usage * low and eliminate the need for reserving new memory whenever a new tile is * needed. * * Default value: false. */ reuseTiles?: boolean; } } declare module L { export class Transformation { /** * Creates a transformation object with the given coefficients. */ constructor(a: number, b: number, c: number, d: number); /** * Returns a transformed point, optionally multiplied by the given scale. * Only accepts real L.Point instances, not arrays. */ transform(point: Point, scale?: number): Point; /** * Returns the reverse transformation of the given point, optionally divided * by the given scale. Only accepts real L.Point instances, not arrays. */ untransform(point: Point, scale?: number): Point; } } declare module L { export class Util { /** * Merges the properties of the src object (or multiple objects) into dest object * and returns the latter. Has an L.extend shortcut. */ static extend(dest: any, ...sources: any[]): any; /** * Returns a function which executes function fn with the given scope obj (so * that this keyword refers to obj inside the function code). Has an L.bind shortcut. */ static bind(fn: T, obj: any): T; /** * Applies a unique key to the object and returns that key. Has an L.stamp shortcut. */ static stamp(obj: any): string; /** * Returns a wrapper around the function fn that makes sure it's called not more * often than a certain time interval time, but as fast as possible otherwise * (for example, it is used for checking and requesting new tiles while dragging * the map), optionally passing the scope (context) in which the function will * be called. */ static limitExecByInterval(fn: T, time: number, context?: any): T; /** * Returns a function which always returns false. */ static falseFn(): () => boolean; /** * Returns the number num rounded to digits decimals. */ static formatNum(num: number, digits: number): number; /** * Trims and splits the string on whitespace and returns the array of parts. */ static splitWords(str: string): string[]; /** * Merges the given properties to the options of the obj object, returning the * resulting options. See Class options. Has an L.setOptions shortcut. */ static setOptions(obj: any, options: any): any; /** * Converts an object into a parameter URL string, e.g. {a: "foo", b: "bar"} * translates to '?a=foo&b=bar'. */ static getParamString(obj: any): string; /** * Simple templating facility, creates a string by applying the values of the * data object of a form {a: 'foo', b: 'bar', …} to a template string of the form * 'Hello {a}, {b}' — in this example you will get 'Hello foo, bar'. */ static template(str: string, data: any): string; /** * Returns true if the given object is an array. */ static isArray(obj: any): boolean; /** * Trims the whitespace from both ends of the string and returns the result. */ static trim(str: string): boolean; /** * Data URI string containing a base64-encoded empty GIF image. Used as a hack * to free memory from unused images on WebKit-powered mobile devices (by setting * image src to this string). */ static emptyImageUrl: string; } } declare module L { export interface WMSOptions { /** * (required) Comma-separated list of WMS layers to show. * * Default value: ''. */ layers?: string; /** * Comma-separated list of WMS styles. * * Default value: 'image/jpeg'. */ styles?: string; /** * WMS image format (use 'image/png' for layers with transparency). * * Default value: false. */ format?: string; /** * If true, the WMS service will return images with transparency. * * Default value: '1.1.1'. */ transparent?: boolean; /** * Version of the WMS service to use. */ version?: string; } } declare module L { export interface ZoomOptions { /** * The position of the control (one of the map corners). See control positions. * * Default value: 'topright'. */ position?: string; } } declare module L { export interface ZoomPanOptions { /** * If true, the map view will be completely reset (without any animations). * * Default value: false. */ reset?: boolean; /** * Sets the options for the panning (without the zoom change) if it occurs. */ pan?: PanOptions; /** * Sets the options for the zoom change if it occurs. */ zoom?: ZoomOptions; /** * An equivalent of passing animate to both zoom and pan options (see below). */ animate?: boolean; } } /** * Forces Leaflet to use the Canvas back-end (if available) for vector layers * instead of SVG. This can increase performance considerably in some cases * (e.g. many thousands of circle markers on the map). */ declare var L_PREFER_CANVAS: boolean; /** * Forces Leaflet to not use touch events even if it detects them. */ declare var L_NO_TOUCH: boolean; /** * Forces Leaflet to not use hardware-accelerated CSS 3D transforms for positioning * (which may cause glitches in some rare environments) even if they're supported. */ declare var L_DISABLE_3D: boolean;