@geoimpact/sep-map-sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2485 @@
+interface Address {
+    id: number;
+    label: string;
+    street: string;
+    houseNumber: string;
+    zip: string;
+    town: string;
+    coordinates: [lat: number, lng: number];
+    raw?: Record<string, unknown>;
+}
+
+interface PerimeterProperties {
+    name: string;
+    description?: string;
+    [key: string]: unknown;
+}
+interface Perimeter {
+    id: string;
+    name: string;
+    properties: PerimeterProperties;
+    geometry: GeoJSON.Geometry;
+    centroid: [lat: number, lng: number];
+}
+
+/**
+ * Base layer types supported by the SDK
+ */
+type LayerType = 'raster-tile' | 'wms' | 'wmts' | 'vector-tile' | 'geojson';
+/**
+ * Predefined layer preset identifiers
+ */
+type LayerPresetId = 'osm-standard' | 'osm-humanitarian' | 'osm-topo' | 'swisstopo-color' | 'swisstopo-grey' | 'swisstopo-satellite' | 'swisstopo-cadastral' | 'swisstopo-streets' | 'swisstopo-addresses' | 'swisstopo-vector-light' | 'swisstopo-vector-dark' | 'swisstopo-labels' | 'custom';
+/**
+ * Layer category for grouping in UI
+ */
+type LayerCategory = 'base' | 'overlay' | 'label';
+/**
+ * Base configuration for all layers
+ */
+interface BaseLayerConfig {
+    /** Unique identifier */
+    id: string;
+    /** Display name (can be i18n key) */
+    name: string;
+    /** Layer type */
+    type: LayerType;
+    /** Layer category */
+    category: LayerCategory;
+    /** Whether layer is visible */
+    visible?: boolean;
+    /** Layer opacity (0-1) */
+    opacity?: number;
+    /** Minimum zoom level */
+    minZoom?: number;
+    /** Maximum zoom level */
+    maxZoom?: number;
+    /** Maximum native zoom (for overzooming) */
+    maxNativeZoom?: number;
+    /** Attribution HTML */
+    attribution?: string;
+    /** Z-index order (higher = on top) */
+    zIndex?: number;
+}
+/**
+ * Raster tile layer configuration
+ */
+interface RasterTileLayerConfig extends BaseLayerConfig {
+    type: 'raster-tile';
+    /** URL template with {x}, {y}, {z} placeholders */
+    url: string;
+    /** Subdomains for load balancing */
+    subdomains?: string | string[];
+    /** Tile size in pixels */
+    tileSize?: number;
+    /** Enable retina tiles (@2x) */
+    retina?: boolean;
+}
+/**
+ * WMS layer configuration
+ */
+interface WMSLayerConfig extends BaseLayerConfig {
+    type: 'wms';
+    /** WMS service base URL */
+    url: string;
+    /** WMS layer names */
+    layers: string;
+    /** Image format */
+    format?: 'image/png' | 'image/jpeg' | 'image/gif';
+    /** Transparent background */
+    transparent?: boolean;
+    /** WMS version */
+    version?: '1.1.1' | '1.3.0';
+    /** Additional WMS parameters */
+    params?: Record<string, string>;
+}
+/**
+ * Vector tile layer configuration (MapLibre GL)
+ */
+interface VectorTileLayerConfig extends BaseLayerConfig {
+    type: 'vector-tile';
+    /** MapLibre GL style specification */
+    style: maplibregl.StyleSpecification;
+    /** Interactive (allows click events) */
+    interactive?: boolean;
+}
+/**
+ * GeoJSON overlay layer configuration
+ */
+interface GeoJSONLayerConfig extends BaseLayerConfig {
+    type: 'geojson';
+    /** GeoJSON data or URL to fetch */
+    data: GeoJSON.GeoJSON | string;
+    /** Style options */
+    style?: {
+        color?: string;
+        weight?: number;
+        opacity?: number;
+        fillColor?: string;
+        fillOpacity?: number;
+    };
+    /** Cluster points */
+    cluster?: boolean;
+    /** Click handler */
+    onClick?: (feature: GeoJSON.Feature) => void;
+}
+/**
+ * Union type of all layer configurations
+ */
+type LayerConfig = RasterTileLayerConfig | WMSLayerConfig | VectorTileLayerConfig | GeoJSONLayerConfig;
+/**
+ * Helper options for adding a WMS layer
+ */
+interface AddWMSLayerOptions {
+    id: string;
+    name: string;
+    url: string;
+    layers: string;
+    visible?: boolean;
+    transparent?: boolean;
+    format?: 'image/png' | 'image/jpeg' | 'image/gif';
+    opacity?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    params?: Record<string, string>;
+    attribution?: string;
+}
+/**
+ * Helper options for adding a tile layer
+ */
+interface AddTileLayerOptions {
+    id: string;
+    name: string;
+    url: string;
+    visible?: boolean;
+    maxZoom?: number;
+    minZoom?: number;
+    subdomains?: string | string[];
+    attribution?: string;
+    opacity?: number;
+}
+/**
+ * Helper options for adding a GeoJSON layer
+ */
+interface AddGeoJSONLayerOptions {
+    id: string;
+    name: string;
+    data: GeoJSON.GeoJSON | string;
+    visible?: boolean;
+    style?: {
+        color?: string;
+        weight?: number;
+        opacity?: number;
+        fillColor?: string;
+        fillOpacity?: number;
+    };
+    cluster?: boolean;
+    onClick?: (feature: GeoJSON.Feature) => void;
+}
+/**
+ * Map layer configuration for the SDK
+ */
+interface MapLayersConfig {
+    /** Base layer preset ID or custom config */
+    baseLayer: LayerPresetId | LayerConfig;
+    /** Overlay layers (on top of base) */
+    overlays?: Array<LayerPresetId | LayerConfig>;
+    /** Whether to show layer control UI */
+    showLayerControl?: boolean;
+    /** Available base layers for switcher (supports both presets and custom configs) */
+    availableBaseLayers?: Array<LayerPresetId | LayerConfig>;
+    /** Available overlay layers for toggling (supports both presets and custom configs) */
+    availableOverlays?: Array<LayerPresetId | LayerConfig>;
+    /** Additional custom layers that are always rendered (not in layer control) */
+    customLayers?: LayerConfig[];
+    /** Callback when a layer is added */
+    onLayerAdd?: (layer: LayerConfig) => void;
+    /** Callback when a layer is removed */
+    onLayerRemove?: (layer: LayerConfig) => void;
+    /** Callback when a layer visibility changes */
+    onLayerVisibilityChange?: (layerId: string, visible: boolean) => void;
+}
+
+interface SEPMapConfig {
+    clientId: string;
+    token?: string;
+    apiUrl?: string;
+    /** Container property for convenience (not used in core config but in initialization) */
+    container?: string | HTMLElement;
+    /** Whether to use Shadow DOM (default: true) */
+    useShadowDom?: boolean;
+    language?: SupportedLocale;
+    /** Custom translations to override defaults (deeply merged) */
+    translations?: Record<string, any>;
+    features?: FeatureConfig;
+    map?: MapConfig;
+    ui?: UIConfig;
+}
+interface FeatureConfig {
+    addressSearch?: boolean;
+    perimeterSelection?: boolean;
+    mapClickSelect?: boolean;
+    multiSelect?: boolean | {
+        maxSelections?: number;
+    };
+    polygonDraw?: boolean;
+    search?: SearchConfig;
+}
+interface SearchConfig {
+    mode?: 'normal' | 'advanced' | 'perimeter' | 'all';
+    prefetchPerimeters?: boolean;
+    districts?: number[];
+    cantons?: string[];
+    renderResultChip?: (item: any, type: 'address' | 'parcel' | 'region' | 'egid' | 'egrid') => React.ReactNode;
+}
+/**
+ * Options for flyTo animations
+ */
+interface FlyToOptions {
+    /** Whether to animate the transition. Default: true */
+    animate?: boolean;
+    /** Animation duration in seconds. Default: 0.25 (Leaflet default) */
+    duration?: number;
+    /** Easing function. Default: 'easeLinearity' */
+    easeLinearity?: number;
+    /** If true, panning will always be animated. Default: false */
+    noMoveStart?: boolean;
+}
+interface MapConfig {
+    center?: [lat: number, lng: number];
+    zoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    bounds?: [[number, number], [number, number]];
+    maxBounds?: [[number, number], [number, number]];
+    attribution?: string | {
+        text: string;
+        position?: 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
+        prefix?: string | false;
+    };
+    /** Default options for flyTo animations */
+    flyTo?: FlyToOptions;
+    /**
+     * Layer configuration for base layers and overlays.
+     * Allows setting the default layer even when layer control is hidden.
+     *
+     * @example
+     * ```typescript
+     * layers: {
+     *   baseLayer: 'swisstopo-color',  // Use color map instead of satellite
+     *   overlays: ['swisstopo-cadastral']
+     * }
+     * ```
+     *
+     * Available base layers: 'swisstopo-satellite', 'swisstopo-color', 'swisstopo-grey',
+     * 'osm-standard', 'osm-humanitarian', 'osm-topo'
+     *
+     * Available overlays: 'swisstopo-cadastral', 'swisstopo-vector-light',
+     * 'swisstopo-streets', 'swisstopo-addresses'
+     */
+    layers?: MapLayersConfig;
+}
+interface MarkerConfig {
+    /** URL to marker icon image (PNG, SVG, etc.) */
+    iconUrl?: string;
+    /** Icon size in pixels [width, height] */
+    iconSize?: [number, number];
+    /** Icon anchor point [x, y] - point of the icon which will correspond to marker's location */
+    iconAnchor?: [number, number];
+    /** Popup anchor point [x, y] - point from which the popup should open relative to the iconAnchor */
+    popupAnchor?: [number, number];
+    /** Shadow image URL */
+    shadowUrl?: string;
+    /** Shadow size in pixels [width, height] */
+    shadowSize?: [number, number];
+    /** Shadow anchor point [x, y] */
+    shadowAnchor?: [number, number];
+    /** CSS class name added to the icon element */
+    className?: string;
+}
+/**
+ * Search UI customization options
+ */
+interface SearchUIConfig {
+    /** Custom CSS class for the search container */
+    className?: string;
+    /** Custom inline styles for the search container */
+    style?: React.CSSProperties;
+    /** Custom placeholder text */
+    placeholder?: string;
+    /** Width of the search input (CSS value, e.g., '300px', '100%') */
+    width?: string;
+}
+interface UIConfig {
+    searchPlacement?: 'top-left' | 'top-right' | 'external';
+    layerControlPosition?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    showLayerControl?: boolean;
+    theme?: 'light' | 'dark';
+    externalSearchContainer?: HTMLElement;
+    /** Custom marker icon configuration */
+    marker?: MarkerConfig;
+    /** Custom search UI configuration */
+    search?: SearchUIConfig;
+    /** Custom CSS to inject into the map container (works with Shadow DOM) */
+    customCss?: string;
+}
+
+type SelectionItem = {
+    type: 'address';
+    data: Address;
+} | {
+    type: 'perimeter';
+    data: Perimeter;
+};
+interface DecisionTreeResult {
+    clientId: string;
+    context: 'address' | 'perimeter' | 'multi';
+    selection: SelectionItem | SelectionItem[];
+    result: Record<string, any>;
+}
+
+// Note: as of the RFC 7946 version of GeoJSON, Coordinate Reference Systems
+// are no longer supported. (See https://tools.ietf.org/html/rfc7946#appendix-B)}
+
+
+
+/**
+ * The value values for the "type" property of GeoJSON Objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+type GeoJsonTypes = GeoJSON$1["type"];
+
+/**
+ * Bounding box
+ * https://tools.ietf.org/html/rfc7946#section-5
+ */
+type BBox = [number, number, number, number] | [number, number, number, number, number, number];
+
+/**
+ * A Position is an array of coordinates.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.1
+ * Array should contain between two and three elements.
+ * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
+ * but the current specification only allows X, Y, and (optionally) Z to be defined.
+ *
+ * Note: the type will not be narrowed down to `[number, number] | [number, number, number]` due to
+ * marginal benefits and the large impact of breaking change.
+ *
+ * See previous discussions on the type narrowing:
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/21590|Nov 2017}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/67773|Dec 2023}
+ * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71441| Dec 2024}
+ *
+ * One can use a
+ * {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates|user-defined type guard that returns a type predicate}
+ * to determine if a position is a 2D or 3D position.
+ *
+ * @example
+ * import type { Position } from 'geojson';
+ *
+ * type StrictPosition = [x: number, y: number] | [x: number, y: number, z: number]
+ *
+ * function isStrictPosition(position: Position): position is StrictPosition {
+ *   return position.length === 2 || position.length === 3
+ * };
+ *
+ * let position: Position = [-116.91, 45.54];
+ *
+ * let x: number;
+ * let y: number;
+ * let z: number | undefined;
+ *
+ * if (isStrictPosition(position)) {
+ *   // `tsc` would throw an error if we tried to destructure a fourth parameter
+ * 	 [x, y, z] = position;
+ * } else {
+ * 	 throw new TypeError("Position is not a 2D or 3D point");
+ * }
+ */
+type Position = number[];
+
+/**
+ * The base GeoJSON object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ * The GeoJSON specification also allows foreign members
+ * (https://tools.ietf.org/html/rfc7946#section-6.1)
+ * Developers should use "&" type in TypeScript or extend the interface
+ * to add these foreign members.
+ */
+interface GeoJsonObject {
+    // Don't include foreign members directly into this type def.
+    // in order to preserve type safety.
+    // [key: string]: any;
+    /**
+     * Specifies the type of GeoJSON object.
+     */
+    type: GeoJsonTypes;
+    /**
+     * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
+     * The value of the bbox member is an array of length 2*n where n is the number of dimensions
+     * represented in the contained geometries, with all axes of the most southwesterly point
+     * followed by all axes of the more northeasterly point.
+     * The axes order of a bbox follows the axes order of geometries.
+     * https://tools.ietf.org/html/rfc7946#section-5
+     */
+    bbox?: BBox | undefined;
+}
+
+/**
+ * Union of GeoJSON objects.
+ */
+type GeoJSON$1<G extends Geometry | null = Geometry, P = GeoJsonProperties> =
+    | G
+    | Feature<G, P>
+    | FeatureCollection<G, P>;
+
+/**
+ * Geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ */
+type Geometry = Point$1 | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
+type GeometryObject = Geometry;
+
+/**
+ * Point geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.2
+ */
+interface Point$1 extends GeoJsonObject {
+    type: "Point";
+    coordinates: Position;
+}
+
+/**
+ * MultiPoint geometry object.
+ *  https://tools.ietf.org/html/rfc7946#section-3.1.3
+ */
+interface MultiPoint extends GeoJsonObject {
+    type: "MultiPoint";
+    coordinates: Position[];
+}
+
+/**
+ * LineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.4
+ */
+interface LineString extends GeoJsonObject {
+    type: "LineString";
+    coordinates: Position[];
+}
+
+/**
+ * MultiLineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.5
+ */
+interface MultiLineString extends GeoJsonObject {
+    type: "MultiLineString";
+    coordinates: Position[][];
+}
+
+/**
+ * Polygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ */
+interface Polygon extends GeoJsonObject {
+    type: "Polygon";
+    coordinates: Position[][];
+}
+
+/**
+ * MultiPolygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.7
+ */
+interface MultiPolygon extends GeoJsonObject {
+    type: "MultiPolygon";
+    coordinates: Position[][][];
+}
+
+/**
+ * Geometry Collection
+ * https://tools.ietf.org/html/rfc7946#section-3.1.8
+ */
+interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
+    type: "GeometryCollection";
+    geometries: G[];
+}
+
+type GeoJsonProperties = { [name: string]: any } | null;
+
+/**
+ * A feature object which contains a geometry and associated properties.
+ * https://tools.ietf.org/html/rfc7946#section-3.2
+ */
+interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+    type: "Feature";
+    /**
+     * The feature's geometry
+     */
+    geometry: G;
+    /**
+     * A value that uniquely identifies this feature in a
+     * https://tools.ietf.org/html/rfc7946#section-3.2.
+     */
+    id?: string | number | undefined;
+    /**
+     * Properties associated with this feature.
+     */
+    properties: P;
+}
+
+/**
+ * A collection of feature objects.
+ *  https://tools.ietf.org/html/rfc7946#section-3.3
+ */
+interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+    type: "FeatureCollection";
+    features: Array<Feature<G, P>>;
+}
+
+declare class Class {
+    static extend(props: any): { new(...args: any[]): any } & typeof Class;
+    static include(props: any): any & typeof Class;
+    static mergeOptions(props: any): any & typeof Class;
+
+    static addInitHook(initHookFn: () => void): any & typeof Class;
+    static addInitHook(methodName: string, ...args: any[]): any & typeof Class;
+
+    static callInitHooks(): void;
+}
+
+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 | undefined;
+    wrapLng?: [number, number] | undefined;
+    wrapLat?: [number, number] | undefined;
+    infinite: boolean;
+}
+
+declare namespace CRS {
+    const EPSG3395: CRS;
+    const EPSG3857: CRS;
+    const EPSG4326: CRS;
+    const EPSG900913: CRS;
+    const Earth: CRS;
+    const Simple: CRS;
+}
+
+declare 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;
+    clone(): LatLng;
+
+    lat: number;
+    lng: number;
+    alt?: number | undefined;
+}
+
+interface LatLngLiteral {
+    lat: number;
+    lng: number;
+    alt?: number;
+}
+
+type LatLngTuple = [number, number, number?];
+
+type LatLngExpression = LatLng | LatLngLiteral | LatLngTuple;
+
+declare class LatLngBounds {
+    constructor(southWest: LatLngExpression, northEast: LatLngExpression);
+    constructor(latlngs: LatLngExpression[]);
+    extend(latlngOrBounds: LatLngExpression | LatLngBoundsExpression): this;
+    pad(bufferRatio: number): LatLngBounds; // Returns a new LatLngBounds
+    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: LatLngBoundsExpression): boolean;
+    toBBoxString(): string;
+    equals(otherBounds: LatLngBoundsExpression, maxMargin?: number): boolean;
+    isValid(): boolean;
+}
+
+type LatLngBoundsLiteral = LatLngTuple[]; // Must be [LatLngTuple, LatLngTuple], cant't change because Map.setMaxBounds
+
+type LatLngBoundsExpression = LatLngBounds | LatLngBoundsLiteral;
+
+type PointTuple = [number, number];
+
+declare 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;
+    trunc(): Point;
+    distanceTo(otherPoint: PointExpression): number;
+    equals(otherPoint: PointExpression): boolean;
+    contains(otherPoint: PointExpression): boolean;
+    toString(): string;
+    x: number;
+    y: number;
+}
+
+interface Coords extends Point {
+    z: number;
+}
+
+type PointExpression = Point | PointTuple;
+
+type BoundsLiteral = [PointTuple, PointTuple];
+
+declare class Bounds {
+    constructor(topLeft: PointExpression, bottomRight: PointExpression);
+    constructor(points?: Point[] | BoundsLiteral);
+
+    // tslint:disable:unified-signatures
+    extend(point: PointExpression): this;
+    extend(otherBounds: BoundsExpression): this;
+    // tslint:enable:unified-signatures
+
+    getCenter(round?: boolean): Point;
+    getBottomLeft(): Point;
+    getBottomRight(): Point;
+    getTopLeft(): Point;
+    getTopRight(): Point;
+    getSize(): Point;
+    contains(pointOrBounds: BoundsExpression | PointExpression): boolean;
+    intersects(otherBounds: BoundsExpression): boolean;
+    overlaps(otherBounds: BoundsExpression): boolean;
+    isValid(): boolean;
+    pad(bufferRatio: number): Bounds; // Returns a new Bounds
+    equals(otherBounds: BoundsExpression): boolean;
+
+    min?: Point | undefined;
+    max?: Point | undefined;
+}
+
+type BoundsExpression = Bounds | BoundsLiteral;
+
+// Event handler types
+
+type LeafletEventHandlerFn = (event: LeafletEvent) => void;
+
+type LayersControlEventHandlerFn = (event: LayersControlEvent) => void;
+
+type LayerEventHandlerFn = (event: LayerEvent) => void;
+
+type ResizeEventHandlerFn = (event: ResizeEvent) => void;
+
+type PopupEventHandlerFn = (event: PopupEvent) => void;
+
+type TooltipEventHandlerFn = (event: TooltipEvent) => void;
+
+type ErrorEventHandlerFn = (event: ErrorEvent) => void;
+
+type LocationEventHandlerFn = (event: LocationEvent) => void;
+
+type LeafletMouseEventHandlerFn = (event: LeafletMouseEvent) => void;
+
+type LeafletKeyboardEventHandlerFn = (event: LeafletKeyboardEvent) => void;
+
+type ZoomAnimEventHandlerFn = (event: ZoomAnimEvent) => void;
+
+type DragEndEventHandlerFn = (event: DragEndEvent) => void;
+
+type TileEventHandlerFn = (event: TileEvent) => void;
+
+type TileErrorEventHandlerFn = (event: TileErrorEvent) => void;
+
+interface LeafletEventHandlerFnMap {
+    baselayerchange?: LayersControlEventHandlerFn | undefined;
+    overlayadd?: LayersControlEventHandlerFn | undefined;
+    overlayremove?: LayersControlEventHandlerFn | undefined;
+
+    layeradd?: LayerEventHandlerFn | undefined;
+    layerremove?: LayerEventHandlerFn | undefined;
+
+    zoomlevelschange?: LeafletEventHandlerFn | undefined;
+    unload?: LeafletEventHandlerFn | undefined;
+    viewreset?: LeafletEventHandlerFn | undefined;
+    load?: LeafletEventHandlerFn | undefined;
+    zoomstart?: LeafletEventHandlerFn | undefined;
+    movestart?: LeafletEventHandlerFn | undefined;
+    zoom?: LeafletEventHandlerFn | undefined;
+    move?: LeafletEventHandlerFn | undefined;
+    zoomend?: LeafletEventHandlerFn | undefined;
+    moveend?: LeafletEventHandlerFn | undefined;
+    autopanstart?: LeafletEventHandlerFn | undefined;
+    dragstart?: LeafletEventHandlerFn | undefined;
+    drag?: LeafletEventHandlerFn | undefined;
+    add?: LeafletEventHandlerFn | undefined;
+    remove?: LeafletEventHandlerFn | undefined;
+    loading?: LeafletEventHandlerFn | undefined;
+    error?: LeafletEventHandlerFn | undefined;
+    update?: LeafletEventHandlerFn | undefined;
+    down?: LeafletEventHandlerFn | undefined;
+    predrag?: LeafletEventHandlerFn | undefined;
+
+    resize?: ResizeEventHandlerFn | undefined;
+
+    popupopen?: PopupEventHandlerFn | undefined;
+    popupclose?: PopupEventHandlerFn | undefined;
+
+    tooltipopen?: TooltipEventHandlerFn | undefined;
+    tooltipclose?: TooltipEventHandlerFn | undefined;
+
+    locationerror?: ErrorEventHandlerFn | undefined;
+
+    locationfound?: LocationEventHandlerFn | undefined;
+
+    click?: LeafletMouseEventHandlerFn | undefined;
+    dblclick?: LeafletMouseEventHandlerFn | undefined;
+    mousedown?: LeafletMouseEventHandlerFn | undefined;
+    mouseup?: LeafletMouseEventHandlerFn | undefined;
+    mouseover?: LeafletMouseEventHandlerFn | undefined;
+    mouseout?: LeafletMouseEventHandlerFn | undefined;
+    mousemove?: LeafletMouseEventHandlerFn | undefined;
+    contextmenu?: LeafletMouseEventHandlerFn | undefined;
+    preclick?: LeafletMouseEventHandlerFn | undefined;
+
+    keypress?: LeafletKeyboardEventHandlerFn | undefined;
+    keydown?: LeafletKeyboardEventHandlerFn | undefined;
+    keyup?: LeafletKeyboardEventHandlerFn | undefined;
+
+    zoomanim?: ZoomAnimEventHandlerFn | undefined;
+
+    dragend?: DragEndEventHandlerFn | undefined;
+
+    tileunload?: TileEventHandlerFn | undefined;
+    tileloadstart?: TileEventHandlerFn | undefined;
+    tileload?: TileEventHandlerFn | undefined;
+    tileabort?: TileEventHandlerFn | undefined;
+
+    tileerror?: TileErrorEventHandlerFn | undefined;
+
+    // [name: string]: any;
+    // You are able add additional properties, but it makes this interface uncheckable.
+}
+
+/**
+ * Base class of Leaflet classes supporting events
+ */
+declare 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').
+     */
+    // tslint:disable:unified-signatures
+    on(type: "baselayerchange" | "overlayadd" | "overlayremove", fn: LayersControlEventHandlerFn, context?: any): this;
+    on(type: "layeradd" | "layerremove", fn: LayerEventHandlerFn, context?: any): this;
+    on(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn: LeafletEventHandlerFn,
+        context?: any,
+    ): this;
+    on(type: "resize", fn: ResizeEventHandlerFn, context?: any): this;
+    on(type: "popupopen" | "popupclose", fn: PopupEventHandlerFn, context?: any): this;
+    on(type: "tooltipopen" | "tooltipclose", fn: TooltipEventHandlerFn, context?: any): this;
+    on(type: "locationerror", fn: ErrorEventHandlerFn, context?: any): this;
+    on(type: "locationfound", fn: LocationEventHandlerFn, context?: any): this;
+    on(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn: LeafletMouseEventHandlerFn,
+        context?: any,
+    ): this;
+    on(type: "keypress" | "keydown" | "keyup", fn: LeafletKeyboardEventHandlerFn, context?: any): this;
+    on(type: "zoomanim", fn: ZoomAnimEventHandlerFn, context?: any): this;
+    on(type: "dragend", fn: DragEndEventHandlerFn, context?: any): this;
+    on(type: "tileunload" | "tileloadstart" | "tileload" | "tileabort", fn: TileEventHandlerFn, context?: any): this;
+    on(type: "tileerror", fn: TileErrorEventHandlerFn, context?: any): this;
+    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:enable:unified-signatures
+
+    /**
+     * 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.
+     */
+    // tslint:disable:unified-signatures
+    off(
+        type: "baselayerchange" | "overlayadd" | "overlayremove",
+        fn?: LayersControlEventHandlerFn,
+        context?: any,
+    ): this;
+    off(type: "layeradd" | "layerremove", fn?: LayerEventHandlerFn, context?: any): this;
+    off(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn?: LeafletEventHandlerFn,
+        context?: any,
+    ): this;
+    off(type: "resize", fn?: ResizeEventHandlerFn, context?: any): this;
+    off(type: "popupopen" | "popupclose", fn?: PopupEventHandlerFn, context?: any): this;
+    off(type: "tooltipopen" | "tooltipclose", fn?: TooltipEventHandlerFn, context?: any): this;
+    off(type: "locationerror", fn?: ErrorEventHandlerFn, context?: any): this;
+    off(type: "locationfound", fn?: LocationEventHandlerFn, context?: any): this;
+    off(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn?: LeafletMouseEventHandlerFn,
+        context?: any,
+    ): this;
+    off(type: "keypress" | "keydown" | "keyup", fn?: LeafletKeyboardEventHandlerFn, context?: any): this;
+    off(type: "zoomanim", fn?: ZoomAnimEventHandlerFn, context?: any): this;
+    off(type: "dragend", fn?: DragEndEventHandlerFn, context?: any): this;
+    off(type: "tileunload" | "tileloadstart" | "tileload" | "tileabort", fn?: TileEventHandlerFn, context?: any): this;
+    off(type: "tileerror", fn?: TileErrorEventHandlerFn, context?: any): this;
+    off(type: string, fn?: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Removes a set of type/listener pairs.
+     */
+    // With an eventMap there are no additional arguments allowed
+    off(eventMap: LeafletEventHandlerFnMap): this;
+
+    /**
+     * Removes all listeners to all events on the object.
+     */
+    off(): this;
+    // tslint:enable:unified-signatures
+
+    /**
+     * 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.
+     */
+    // tslint:disable:unified-signatures
+    listens(
+        type:
+            | "baselayerchange"
+            | "overlayadd"
+            | "overlayremove"
+            | "layeradd"
+            | "layerremove"
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag"
+            | "resize"
+            | "popupopen"
+            | "tooltipopen"
+            | "tooltipclose"
+            | "locationerror"
+            | "locationfound"
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick"
+            | "keypress"
+            | "keydown"
+            | "keyup"
+            | "zoomanim"
+            | "dragend"
+            | "tileunload"
+            | "tileloadstart"
+            | "tileload"
+            | "tileabort"
+            | "tileerror",
+        propagate?: boolean,
+    ): boolean;
+
+    listens(
+        type: "baselayerchange" | "overlayadd" | "overlayremove",
+        fn: LayersControlEventHandlerFn,
+        context?: any,
+        propagate?: boolean,
+    ): boolean;
+    listens(type: "layeradd" | "layerremove", fn: LayerEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn: LeafletEventHandlerFn,
+        context?: any,
+        propagate?: boolean,
+    ): boolean;
+    listens(type: "resize", fn: ResizeEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(type: "popupopen" | "popupclose", fn: PopupEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(
+        type: "tooltipopen" | "tooltipclose",
+        fn: TooltipEventHandlerFn,
+        context?: any,
+        propagate?: boolean,
+    ): boolean;
+    listens(type: "locationerror", fn: ErrorEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(type: "locationfound", fn: LocationEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn: LeafletMouseEventHandlerFn,
+        context?: any,
+        propagate?: boolean,
+    ): boolean;
+    listens(
+        type: "keypress" | "keydown" | "keyup",
+        fn: LeafletKeyboardEventHandlerFn,
+        context?: any,
+        propagate?: boolean,
+    ): boolean;
+    listens(type: "zoomanim", fn: ZoomAnimEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(type: "dragend", fn: DragEndEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(
+        type: "tileunload" | "tileloadstart" | "tileload" | "tileabort",
+        fn: TileEventHandlerFn,
+        context?: any,
+        propagate?: boolean,
+    ): boolean;
+    listens(type: "tileerror", fn: TileEventHandlerFn, context?: any, propagate?: boolean): boolean;
+    listens(type: string, fn: LeafletEventHandlerFn, context?: any, propagate?: boolean): boolean;
+
+    /**
+     * Behaves as on(...), except the listener will only get fired once and then removed.
+     */
+    // tslint:disable:unified-signatures
+    once(
+        type: "baselayerchange" | "overlayadd" | "overlayremove",
+        fn: LayersControlEventHandlerFn,
+        context?: any,
+    ): this;
+    once(type: "layeradd" | "layerremove", fn: LayerEventHandlerFn, context?: any): this;
+    once(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn: LeafletEventHandlerFn,
+        context?: any,
+    ): this;
+    once(type: "resize", fn: ResizeEventHandlerFn, context?: any): this;
+    once(type: "popupopen" | "popupclose", fn: PopupEventHandlerFn, context?: any): this;
+    once(type: "tooltipopen" | "tooltipclose", fn: TooltipEventHandlerFn, context?: any): this;
+    once(type: "locationerror", fn: ErrorEventHandlerFn, context?: any): this;
+    once(type: "locationfound", fn: LocationEventHandlerFn, context?: any): this;
+    once(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn: LeafletMouseEventHandlerFn,
+        context?: any,
+    ): this;
+    once(type: "keypress" | "keydown" | "keyup", fn: LeafletKeyboardEventHandlerFn, context?: any): this;
+    once(type: "zoomanim", fn: ZoomAnimEventHandlerFn, context?: any): this;
+    once(type: "dragend", fn: DragEndEventHandlerFn, context?: any): this;
+    once(type: "tileunload" | "tileloadstart" | "tileload" | "tileabort", fn: TileEventHandlerFn, context?: any): this;
+    once(type: "tileerror", fn: TileEventHandlerFn, context?: any): this;
+    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;
+    // tslint:enable:unified-signatures
+
+    /**
+     * 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').
+     */
+    // tslint:disable:unified-signatures
+    addEventListener(
+        type: "baselayerchange" | "overlayadd" | "overlayremove",
+        fn: LayersControlEventHandlerFn,
+        context?: any,
+    ): this;
+    addEventListener(type: "layeradd" | "layerremove", fn: LayerEventHandlerFn, context?: any): this;
+    addEventListener(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn: LeafletEventHandlerFn,
+        context?: any,
+    ): this;
+    addEventListener(type: "resize", fn: ResizeEventHandlerFn, context?: any): this;
+    addEventListener(type: "popupopen" | "popupclose", fn: PopupEventHandlerFn, context?: any): this;
+    addEventListener(type: "tooltipopen" | "tooltipclose", fn: TooltipEventHandlerFn, context?: any): this;
+    addEventListener(type: "locationerror", fn: ErrorEventHandlerFn, context?: any): this;
+    addEventListener(type: "locationfound", fn: LocationEventHandlerFn, context?: any): this;
+    addEventListener(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn: LeafletMouseEventHandlerFn,
+        context?: any,
+    ): this;
+    addEventListener(type: "keypress" | "keydown" | "keyup", fn: LeafletKeyboardEventHandlerFn, context?: any): this;
+    addEventListener(type: "zoomanim", fn: ZoomAnimEventHandlerFn, context?: any): this;
+    addEventListener(type: "dragend", fn: DragEndEventHandlerFn, context?: any): this;
+    addEventListener(
+        type: "tileunload" | "tileloadstart" | "tileload" | "tileabort",
+        fn: TileEventHandlerFn,
+        context?: any,
+    ): this;
+    addEventListener(type: "tileerror", fn: TileErrorEventHandlerFn, context?: any): this;
+    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;
+    // tslint:enable:unified-signatures
+
+    /**
+     * 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.
+     */
+    // tslint:disable:unified-signatures
+    removeEventListener(
+        type: "baselayerchange" | "overlayadd" | "overlayremove",
+        fn?: LayersControlEventHandlerFn,
+        context?: any,
+    ): this;
+    removeEventListener(type: "layeradd" | "layerremove", fn?: LayerEventHandlerFn, context?: any): this;
+    removeEventListener(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn?: LeafletEventHandlerFn,
+        context?: any,
+    ): this;
+    removeEventListener(type: "resize", fn?: ResizeEventHandlerFn, context?: any): this;
+    removeEventListener(type: "popupopen" | "popupclose", fn?: PopupEventHandlerFn, context?: any): this;
+    removeEventListener(type: "tooltipopen" | "tooltipclose", fn?: TooltipEventHandlerFn, context?: any): this;
+    removeEventListener(type: "locationerror", fn?: ErrorEventHandlerFn, context?: any): this;
+    removeEventListener(type: "locationfound", fn?: LocationEventHandlerFn, context?: any): this;
+    removeEventListener(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn?: LeafletMouseEventHandlerFn,
+        context?: any,
+    ): this;
+    removeEventListener(
+        type: "keypress" | "keydown" | "keyup",
+        fn?: LeafletKeyboardEventHandlerFn,
+        context?: any,
+    ): this;
+    removeEventListener(type: "zoomanim", fn?: ZoomAnimEventHandlerFn, context?: any): this;
+    removeEventListener(type: "dragend", fn?: DragEndEventHandlerFn, context?: any): this;
+    removeEventListener(
+        type: "tileunload" | "tileloadstart" | "tileload" | "tileabort",
+        fn?: TileEventHandlerFn,
+        context?: any,
+    ): this;
+    removeEventListener(type: "tileerror", fn?: TileErrorEventHandlerFn, context?: any): this;
+    removeEventListener(type: string, fn?: LeafletEventHandlerFn, context?: any): this;
+
+    /**
+     * Alias for off(...)
+     *
+     * Removes a set of type/listener pairs.
+     */
+    removeEventListener(eventMap: LeafletEventHandlerFnMap): this;
+    // tslint:enable:unified-signatures
+
+    /**
+     * 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.
+     */
+    // tslint:disable:unified-signatures
+    addOneTimeEventListener(
+        type: "baselayerchange" | "overlayadd" | "overlayremove",
+        fn: LayersControlEventHandlerFn,
+        context?: any,
+    ): this;
+    addOneTimeEventListener(type: "layeradd" | "layerremove", fn: LayerEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(
+        type:
+            | "zoomlevelschange"
+            | "unload"
+            | "viewreset"
+            | "load"
+            | "zoomstart"
+            | "movestart"
+            | "zoom"
+            | "move"
+            | "zoomend"
+            | "moveend"
+            | "autopanstart"
+            | "dragstart"
+            | "drag"
+            | "add"
+            | "remove"
+            | "loading"
+            | "error"
+            | "update"
+            | "down"
+            | "predrag",
+        fn: LeafletEventHandlerFn,
+        context?: any,
+    ): this;
+    addOneTimeEventListener(type: "resize", fn: ResizeEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(type: "popupopen" | "popupclose", fn: PopupEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(type: "tooltipopen" | "tooltipclose", fn: TooltipEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(type: "locationerror", fn: ErrorEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(type: "locationfound", fn: LocationEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(
+        type:
+            | "click"
+            | "dblclick"
+            | "mousedown"
+            | "mouseup"
+            | "mouseover"
+            | "mouseout"
+            | "mousemove"
+            | "contextmenu"
+            | "preclick",
+        fn: LeafletMouseEventHandlerFn,
+        context?: any,
+    ): this;
+    addOneTimeEventListener(
+        type: "keypress" | "keydown" | "keyup",
+        fn: LeafletKeyboardEventHandlerFn,
+        context?: any,
+    ): this;
+    addOneTimeEventListener(type: "zoomanim", fn: ZoomAnimEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(type: "dragend", fn: DragEndEventHandlerFn, context?: any): this;
+    addOneTimeEventListener(
+        type: "tileunload" | "tileloadstart" | "tileload" | "tileabort",
+        fn: TileEventHandlerFn,
+        context?: any,
+    ): this;
+    addOneTimeEventListener(type: "tileerror", fn: TileErrorEventHandlerFn, context?: any): this;
+    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;
+    // tslint:enable:unified-signatures
+
+    /**
+     * 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;
+}
+
+interface LayerOptions {
+    pane?: string | undefined;
+    attribution?: string | undefined;
+}
+
+interface InteractiveLayerOptions extends LayerOptions {
+    interactive?: boolean | undefined;
+    bubblingMouseEvents?: boolean | undefined;
+}
+
+declare class Layer extends Evented {
+    constructor(options?: LayerOptions);
+    addTo(map: Map | LayerGroup): this;
+    remove(): this;
+    removeFrom(map: Map): this;
+    getPane(name?: string): HTMLElement | undefined;
+
+    addInteractiveTarget(targetEl: HTMLElement): this;
+    removeInteractiveTarget(targetEl: HTMLElement): this;
+
+    // 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]: LeafletEventHandlerFn };
+    getAttribution?(): string | null;
+    beforeAdd?(map: Map): this;
+
+    protected _map: Map;
+
+    options: LayerOptions;
+}
+
+type LineCapShape = "butt" | "round" | "square" | "inherit";
+
+type LineJoinShape = "miter" | "round" | "bevel" | "inherit";
+
+type FillRule = "nonzero" | "evenodd" | "inherit";
+
+interface PathOptions extends InteractiveLayerOptions {
+    stroke?: boolean | undefined;
+    color?: string | undefined;
+    weight?: number | undefined;
+    opacity?: number | undefined;
+    lineCap?: LineCapShape | undefined;
+    lineJoin?: LineJoinShape | undefined;
+    dashArray?: string | number[] | undefined;
+    dashOffset?: string | undefined;
+    fill?: boolean | undefined;
+    fillColor?: string | undefined;
+    fillOpacity?: number | undefined;
+    fillRule?: FillRule | undefined;
+    renderer?: Renderer | undefined;
+    className?: string | undefined;
+}
+
+declare abstract class Path extends Layer {
+    redraw(): this;
+    setStyle(style: PathOptions): this;
+    bringToFront(): this;
+    bringToBack(): this;
+    getElement(): Element | undefined;
+
+    options: PathOptions;
+}
+
+interface RendererOptions extends LayerOptions {
+    padding?: number | undefined;
+    tolerance?: number | undefined;
+}
+
+declare class Renderer extends Layer {
+    constructor(options?: RendererOptions);
+
+    options: RendererOptions;
+}
+
+/**
+ * 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.
+ */
+declare class LayerGroup<P = any> extends Layer {
+    constructor(layers?: Layer[], options?: LayerOptions);
+
+    toMultiPoint(precision?: number): Feature<MultiPoint, P>;
+
+    /**
+     * Returns a GeoJSON representation of the layer group (as a GeoJSON GeometryCollection, GeoJSONFeatureCollection or Multipoint).
+     */
+    toGeoJSON(
+        precision?: number | false,
+    ):
+        | FeatureCollection<GeometryObject, P>
+        | Feature<MultiPoint, P>
+        | 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?:
+        | FeatureCollection<GeometryObject, P>
+        | Feature<MultiPoint, P>
+        | GeometryCollection
+        | undefined;
+}
+
+type Zoom = boolean | "center";
+
+interface MapOptions {
+    preferCanvas?: boolean | undefined;
+
+    // Control options
+    attributionControl?: boolean | undefined;
+    zoomControl?: boolean | undefined;
+
+    // Interaction options
+    closePopupOnClick?: boolean | undefined;
+    zoomSnap?: number | undefined;
+    zoomDelta?: number | undefined;
+    trackResize?: boolean | undefined;
+    boxZoom?: boolean | undefined;
+    doubleClickZoom?: Zoom | undefined;
+    dragging?: boolean | undefined;
+
+    // Map state options
+    crs?: CRS | undefined;
+    center?: LatLngExpression | undefined;
+    zoom?: number | undefined;
+    minZoom?: number | undefined;
+    maxZoom?: number | undefined;
+    layers?: Layer[] | undefined;
+    maxBounds?: LatLngBoundsExpression | undefined;
+    renderer?: Renderer | undefined;
+
+    // Animation options
+    fadeAnimation?: boolean | undefined;
+    markerZoomAnimation?: boolean | undefined;
+    transform3DLimit?: number | undefined;
+    zoomAnimation?: boolean | undefined;
+    zoomAnimationThreshold?: number | undefined;
+
+    // Panning inertia options
+    inertia?: boolean | undefined;
+    inertiaDeceleration?: number | undefined;
+    inertiaMaxSpeed?: number | undefined;
+    easeLinearity?: number | undefined;
+    worldCopyJump?: boolean | undefined;
+    maxBoundsViscosity?: number | undefined;
+
+    // Keyboard navigation options
+    keyboard?: boolean | undefined;
+    keyboardPanDelta?: number | undefined;
+
+    // Mousewheel options
+    scrollWheelZoom?: Zoom | undefined;
+    wheelDebounceTime?: number | undefined;
+    wheelPxPerZoomLevel?: number | undefined;
+
+    // Touch interaction options
+    tapHold?: boolean | undefined;
+    tapTolerance?: number | undefined;
+    touchZoom?: Zoom | undefined;
+    bounceAtZoomLimits?: boolean | undefined;
+}
+
+type ControlPosition = "topleft" | "topright" | "bottomleft" | "bottomright";
+
+interface ControlOptions {
+    position?: ControlPosition | undefined;
+}
+
+declare class Control<Options extends ControlOptions = ControlOptions> extends Class {
+    static extend<T extends object, Options extends ControlOptions = ControlOptions>(
+        props: T,
+    ): { new(...args: any[]): T } & typeof Control<Options>;
+    constructor(options?: Options);
+    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: Options;
+}
+
+declare namespace Control {
+    interface ZoomOptions extends ControlOptions {
+        zoomInText?: string | undefined;
+        zoomInTitle?: string | undefined;
+        zoomOutText?: string | undefined;
+        zoomOutTitle?: string | undefined;
+    }
+
+    class Zoom extends Control {
+        constructor(options?: ZoomOptions);
+        options: ZoomOptions;
+    }
+
+    interface AttributionOptions extends ControlOptions {
+        prefix?: string | boolean | undefined;
+    }
+
+    class Attribution extends Control {
+        constructor(options?: AttributionOptions);
+        setPrefix(prefix: string | false): this;
+        addAttribution(text: string): this;
+        removeAttribution(text: string): this;
+        options: AttributionOptions;
+    }
+
+    interface LayersOptions extends ControlOptions {
+        collapsed?: boolean | undefined;
+        autoZIndex?: boolean | undefined;
+        hideSingleBase?: boolean | undefined;
+        /**
+         * Whether to sort the layers. When `false`, layers will keep the order in which they were added to the control.
+         */
+        sortLayers?: boolean | undefined;
+        /**
+         * A [compare function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+         * that will be used for sorting the layers, when `sortLayers` is `true`. The function receives both the
+         * [`L.Layer`](https://leafletjs.com/reference.html#layer) instances and their names, as in
+         * `sortFunction(layerA, layerB, nameA, nameB)`. By default, it sorts layers alphabetically by their name.
+         */
+        sortFunction?: ((layerA: Layer, layerB: Layer, nameA: string, nameB: string) => number) | undefined;
+    }
+
+    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 | undefined;
+        metric?: boolean | undefined;
+        imperial?: boolean | undefined;
+        updateWhenIdle?: boolean | undefined;
+    }
+
+    class Scale extends Control {
+        constructor(options?: ScaleOptions);
+        options: ScaleOptions;
+    }
+}
+
+interface DivOverlayOptions {
+    offset?: PointExpression | undefined;
+    className?: string | undefined;
+    pane?: string | undefined;
+    interactive?: boolean | undefined;
+    content?: string | HTMLElement | ((layer: Layer) => string) | ((layer: Layer) => HTMLElement);
+}
+
+declare abstract class DivOverlay extends Layer {
+    constructor(latlng: LatLngExpression, options?: TooltipOptions);
+    constructor(options?: DivOverlayOptions, 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;
+    toggle(layer?: Layer): this;
+    close(): this;
+
+    options: DivOverlayOptions;
+}
+
+interface PopupOptions extends DivOverlayOptions {
+    maxWidth?: number | undefined;
+    minWidth?: number | undefined;
+    maxHeight?: number | undefined;
+    keepInView?: boolean | undefined;
+    closeButton?: boolean | undefined;
+    autoPan?: boolean | undefined;
+    autoPanPaddingTopLeft?: PointExpression | undefined;
+    autoPanPaddingBottomRight?: PointExpression | undefined;
+    autoPanPadding?: PointExpression | undefined;
+    autoClose?: boolean | undefined;
+    closeOnClick?: boolean | undefined;
+    closeOnEscapeKey?: boolean | undefined;
+}
+
+type Content = string | HTMLElement;
+
+declare class Popup extends DivOverlay {
+    constructor(latlng: LatLngExpression, options?: TooltipOptions);
+    constructor(options?: PopupOptions, source?: Layer);
+    openOn(map: Map): this;
+
+    options: PopupOptions;
+}
+
+type Direction = "right" | "left" | "top" | "bottom" | "center" | "auto";
+
+interface TooltipOptions extends DivOverlayOptions {
+    pane?: string | undefined;
+    offset?: PointExpression | undefined;
+    direction?: Direction | undefined;
+    permanent?: boolean | undefined;
+    sticky?: boolean | undefined;
+    opacity?: number | undefined;
+}
+
+declare class Tooltip extends DivOverlay {
+    constructor(latlng: LatLngExpression, options?: TooltipOptions);
+    constructor(options?: TooltipOptions, source?: Layer);
+    setOpacity(val: number): void;
+
+    options: TooltipOptions;
+}
+
+interface ZoomOptions {
+    animate?: boolean | undefined;
+}
+
+interface PanOptions {
+    animate?: boolean | undefined;
+    duration?: number | undefined;
+    easeLinearity?: number | undefined;
+    noMoveStart?: boolean | undefined;
+}
+
+// This is not empty, it extends two interfaces into one...
+interface ZoomPanOptions extends ZoomOptions, PanOptions {}
+
+interface InvalidateSizeOptions extends ZoomPanOptions {
+    debounceMoveend?: boolean | undefined;
+    pan?: boolean | undefined;
+}
+
+interface FitBoundsOptions extends ZoomOptions, PanOptions {
+    paddingTopLeft?: PointExpression | undefined;
+    paddingBottomRight?: PointExpression | undefined;
+    padding?: PointExpression | undefined;
+    maxZoom?: number | undefined;
+}
+
+interface PanInsideOptions extends PanOptions {
+    paddingTopLeft?: PointExpression | undefined;
+    paddingBottomRight?: PointExpression | undefined;
+    padding?: PointExpression | undefined;
+}
+
+interface LocateOptions {
+    watch?: boolean | undefined;
+    setView?: boolean | undefined;
+    maxZoom?: number | undefined;
+    timeout?: number | undefined;
+    maximumAge?: number | undefined;
+    enableHighAccuracy?: boolean | undefined;
+}
+
+declare class Handler extends Class {
+    constructor(map: Map);
+    enable(): this;
+    disable(): this;
+    enabled(): boolean;
+
+    // Extension methods
+    addHooks?(): void;
+    removeHooks?(): void;
+}
+
+interface LeafletEvent {
+    type: string;
+    popup: any;
+    target: any;
+    sourceTarget: any;
+    propagatedFrom: any;
+    /**
+     * @deprecated The same as {@link LeafletEvent.propagatedFrom propagatedFrom}.
+     */
+    layer: any;
+}
+
+interface LeafletMouseEvent extends LeafletEvent {
+    latlng: LatLng;
+    layerPoint: Point;
+    containerPoint: Point;
+    originalEvent: MouseEvent;
+}
+
+interface LeafletKeyboardEvent extends LeafletEvent {
+    originalEvent: KeyboardEvent;
+}
+
+interface LocationEvent extends LeafletEvent {
+    latlng: LatLng;
+    bounds: LatLngBounds;
+    accuracy: number;
+    altitude: number;
+    altitudeAccuracy: number;
+    heading: number;
+    speed: number;
+    timestamp: number;
+}
+
+interface ErrorEvent extends LeafletEvent {
+    message: string;
+    code: number;
+}
+
+interface LayerEvent extends LeafletEvent {
+    layer: Layer;
+}
+
+interface LayersControlEvent extends LayerEvent {
+    name: string;
+}
+
+interface TileEvent extends LeafletEvent {
+    tile: HTMLImageElement;
+    coords: Coords;
+}
+
+interface TileErrorEvent extends TileEvent {
+    error: Error;
+}
+
+interface ResizeEvent extends LeafletEvent {
+    oldSize: Point;
+    newSize: Point;
+}
+
+interface PopupEvent extends LeafletEvent {
+    popup: Popup;
+}
+
+interface TooltipEvent extends LeafletEvent {
+    tooltip: Tooltip;
+}
+
+interface DragEndEvent extends LeafletEvent {
+    distance: number;
+}
+
+interface ZoomAnimEvent extends LeafletEvent {
+    center: LatLng;
+    zoom: number;
+    noUpdate: boolean;
+}
+
+interface DefaultMapPanes {
+    mapPane: HTMLElement;
+    tilePane: HTMLElement;
+    overlayPane: HTMLElement;
+    shadowPane: HTMLElement;
+    markerPane: HTMLElement;
+    tooltipPane: HTMLElement;
+    popupPane: HTMLElement;
+}
+
+declare 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, options?: PanOptions): this;
+    setMaxBounds(bounds?: LatLngBoundsExpression): this;
+    setMinZoom(zoom: number): this;
+    setMaxZoom(zoom: number): this;
+    panInside(latLng: LatLngExpression, options?: PanInsideOptions): this;
+    panInsideBounds(bounds: LatLngBoundsExpression, options?: PanOptions): this;
+    /**
+     * Boolean for animate or advanced ZoomPanOptions
+     */
+    invalidateSize(options?: boolean | InvalidateSizeOptions): this;
+    stop(): this;
+    flyTo(latlng: LatLngExpression, zoom?: number, options?: ZoomPanOptions): this;
+    flyToBounds(bounds: LatLngBoundsExpression, options?: FitBoundsOptions): this;
+
+    // Other methods
+    addHandler(name: string, HandlerClass: typeof Handler): this; // Alternatively, HandlerClass: new(map: Map) => Handler
+    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: (event: { target: Map }) => void, context?: any): this;
+
+    // Methods for getting map state
+    getCenter(): LatLng;
+    getZoom(): number;
+    getBounds(): LatLngBounds;
+    getMinZoom(): number;
+    getMaxZoom(): number;
+    getBoundsZoom(bounds: LatLngBoundsExpression, inside?: boolean, padding?: Point): 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
+    attributionControl: L.Control.Attribution;
+    boxZoom: Handler;
+    doubleClickZoom: Handler;
+    dragging: Handler;
+    keyboard: Handler;
+    scrollWheelZoom: Handler;
+    tapHold?: Handler | undefined;
+    touchZoom: Handler;
+    zoomControl: Control.Zoom;
+
+    options: MapOptions;
+}
+
+/**
+ * Public API interface for the SEP Map component
+ * Available when using React ref or SDK instance
+ */
+interface SEPMapRef {
+    selectAddress: (idOrAddress: number | Address) => Promise<Address | null>;
+    selectPerimeter: (idOrPerimeter: string | Perimeter) => Promise<Perimeter | null>;
+    getSelection: () => SelectionItem[];
+    clearSelection: () => void;
+    addToSelection: (item: Address | Perimeter) => boolean;
+    removeFromSelection: (id: string | number) => void;
+    flyTo: (lat: number, lng: number, zoom?: number, options?: FlyToOptions) => void;
+    fitBounds: (bounds: [[number, number], [number, number]]) => void;
+    startPolygonDraw: () => void;
+    cancelPolygonDraw: () => void;
+    addLayer: (layerConfig: LayerConfig) => void;
+    addWMSLayer: (options: AddWMSLayerOptions) => void;
+    addTileLayer: (options: AddTileLayerOptions) => void;
+    addGeoJSONLayer: (options: AddGeoJSONLayerOptions) => void;
+    removeLayer: (layerId: string) => void;
+    toggleLayer: (layerId: string, visible?: boolean) => void;
+    getLayers: () => LayerConfig[];
+    getLayer: (layerId: string) => LayerConfig | undefined;
+    getLeafletMap: () => Map | null;
+}
+
+type SupportedLocale = 'de' | 'fr' | 'it' | 'en';
+
+interface SearchOptions {
+    districts?: number[];
+    limit?: number;
+    signal?: AbortSignal;
+}
+declare class AddressService {
+    private baseUrl;
+    private token;
+    constructor(baseUrl: string, token: string);
+    /**
+     * Search for addresses by query string
+     */
+    search(query: string, options?: SearchOptions): Promise<Address[]>;
+    /**
+     * Advanced search using searchaddress-advanced endpoint
+     */
+    searchAdvanced(query: string, options?: SearchOptions): Promise<Address[]>;
+    /**
+     * Get address by ID
+     */
+    getById(id: number, signal?: AbortSignal): Promise<Address | null>;
+    /**
+     * Get address at coordinates (reverse geocoding)
+     */
+    getByCoordinates(lat: number, lng: number, signal?: AbortSignal): Promise<Address | null>;
+    /**
+     * Get addresses within a polygon
+     */
+    getInPolygon(polygon: GeoJSON.Polygon, signal?: AbortSignal): Promise<Address[]>;
+    /**
+     * Transform API response to Address type
+     */
+    private transformAddress;
+    /**
+     * Build display label from address parts
+     */
+    private buildLabel;
+}
+
+declare class PerimeterService {
+    private baseUrl;
+    private token;
+    constructor(baseUrl: string, token: string);
+    private perimetersCache;
+    private fetchPromise;
+    /**
+     * Get all perimeters (cached)
+     */
+    getAll(): Promise<Perimeter[]>;
+    /**
+     * Search perimeters locally
+     */
+    search(query: string): Promise<Perimeter[]>;
+    getById(id: string): Promise<Perimeter | null>;
+    /**
+     * Find closest perimeter to coordinates
+     * @param lat Latitude
+     * @param lng Longitude
+     * @param maxDistanceKm Maximum distance in kilometers (default 0.1km = 100m)
+     */
+    getClosest(lat: number, lng: number, maxDistanceKm?: number): Promise<Perimeter | null>;
+    private getDistanceFromLatLonInKm;
+    private deg2rad;
+}
+
+declare class ConfigService {
+    private clientId;
+    constructor(_baseUrl: string, clientId: string);
+    evaluateDecisionTree(items: SelectionItem[]): Promise<DecisionTreeResult>;
+}
+
+declare class I18nManager {
+    private locale;
+    private translations;
+    private fallback;
+    private listeners;
+    private static bundledTranslations;
+    private customTranslations;
+    constructor(locale?: SupportedLocale, customTranslations?: Record<string, any>);
+    private updateTranslations;
+    private deepMerge;
+    private detectLocale;
+    private isSupported;
+    t(key: string, values?: Record<string, string | number>): string;
+    setLocale(locale: SupportedLocale): void;
+    getLocale(): SupportedLocale;
+    onLocaleChange(callback: (locale: SupportedLocale) => void): () => void;
+    getSupportedLocales(): {
+        code: string;
+        name: string;
+    }[];
+}
+
+type EventMap = {
+    ready: {
+        map: unknown;
+    };
+    addressSelected: Address;
+    perimeterSelected: Perimeter;
+    selectionChanged: SelectionItem[];
+    polygonDrawn: {
+        polygon: GeoJSON.Polygon;
+        addresses: Address[];
+    };
+    error: {
+        type: string;
+        message: string;
+        error?: Error;
+    };
+    languageChanged: {
+        locale: SupportedLocale;
+    };
+};
+type EventCallback<K extends keyof EventMap> = (data: EventMap[K]) => void;
+declare class SEPMapSDK {
+    private root;
+    private mapRef;
+    private config;
+    private events;
+    private shadowRoot;
+    readonly i18n: I18nManager;
+    readonly services: {
+        address: AddressService;
+        perimeter: PerimeterService;
+        config: ConfigService;
+    };
+    constructor(config: SEPMapConfig);
+    private normalizeConfig;
+    /**
+     * Mount the map to a container element
+     */
+    mount(container: string | HTMLElement): this;
+    /**
+     * Mount search component to external container
+     */
+    mountSearch(container: string | HTMLElement): this;
+    private render;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof EventMap>(event: K, callback: EventCallback<K>): () => void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<K extends keyof EventMap>(event: K, callback: EventCallback<K>): void;
+    /**
+     * Subscribe to an event (fires only once)
+     */
+    once<K extends keyof EventMap>(event: K, callback: EventCallback<K>): () => void;
+    private emit;
+    /**
+     * Select an address programmatically
+     */
+    selectAddress(idOrAddress: number | Address): Promise<Address | null>;
+    /**
+     * Select a perimeter programmatically
+     */
+    selectPerimeter(idOrPerimeter: string | Perimeter): Promise<Perimeter | null>;
+    /**
+     * Get current selection
+     */
+    getSelection(): SelectionItem[];
+    /**
+     * Clear all selections
+     */
+    clearSelection(): void;
+    /**
+     * Add item to selection (for multi-select)
+     */
+    addToSelection(item: Address | Perimeter): boolean;
+    /**
+     * Remove item from selection
+     */
+    removeFromSelection(id: string | number): void;
+    /**
+     * Execute decision tree for current/given selection
+     */
+    getDecisionTree(selection?: SelectionItem[]): Promise<DecisionTreeResult>;
+    /**
+     * Search for addresses
+     */
+    searchAddress(query: string): Promise<Address[]>;
+    /**
+     * Get addresses within a polygon
+     */
+    getAddressesInPolygon(polygon: GeoJSON.Polygon): Promise<Address[]>;
+    /**
+     * Pan/zoom to coordinates with optional animation options
+     * @param lat Latitude
+     * @param lng Longitude
+     * @param zoom Optional zoom level
+     * @param options Optional animation options (animate, duration, easeLinearity)
+     */
+    flyTo(lat: number, lng: number, zoom?: number, options?: FlyToOptions): void;
+    /**
+     * Fit map to bounds
+     */
+    fitBounds(bounds: [[number, number], [number, number]]): void;
+    /**
+     * Change language at runtime
+     */
+    setLanguage(locale: SupportedLocale): void;
+    /**
+     * Get current language
+     */
+    getLanguage(): SupportedLocale;
+    /**
+     * Enable/disable features at runtime
+     */
+    setFeature(feature: keyof SEPMapConfig['features'], enabled: boolean): void;
+    /**
+     * Start polygon drawing mode
+     */
+    startPolygonDraw(): void;
+    /**
+     * Cancel polygon drawing mode
+     */
+    cancelPolygonDraw(): void;
+    /**
+     * Get the underlying Leaflet map instance for advanced usage.
+     *
+     * @returns Leaflet Map instance
+     *
+     * @example
+     * ```typescript
+     * const leafletMap = sdk.getLeafletMap();
+     *
+     * // Add custom Leaflet layer
+     * const customLayer = L.tileLayer('https://{s}.tile.custom.com/{z}/{x}/{y}.png');
+     * customLayer.addTo(leafletMap);
+     *
+     * // Add event listeners
+     * leafletMap.on('click', (e) => {
+     *   console.log('Map clicked at', e.latlng);
+     * });
+     * ```
+     */
+    getLeafletMap(): unknown;
+    /**
+     * Add a custom layer configuration
+     *
+     * @param layerConfig - Complete layer configuration
+     *
+     * @example
+     * ```typescript
+     * sdk.addLayer({
+     *   id: 'my-custom-wms',
+     *   name: 'Custom WMS Layer',
+     *   type: 'wms',
+     *   category: 'overlay',
+     *   url: 'https://my-service.com/wms',
+     *   layers: 'my-layer',
+     *   format: 'image/png',
+     *   transparent: true
+     * });
+     * ```
+     */
+    addLayer(layerConfig: LayerConfig): void;
+    /**
+     * Add a WMS layer with simplified configuration
+     *
+     * @param options - WMS layer options
+     *
+     * @example
+     * ```typescript
+     * sdk.addWMSLayer({
+     *   id: 'my-wms',
+     *   name: 'My WMS Layer',
+     *   url: 'https://my-service.com/wms',
+     *   layers: 'layer-name',
+     *   transparent: true,
+     *   params: {
+     *     TIME: '2024-01-01',
+     *     STYLE: 'default'
+     *   }
+     * });
+     * ```
+     */
+    addWMSLayer(options: AddWMSLayerOptions): void;
+    /**
+     * Add a tile layer with simplified configuration
+     *
+     * @param options - Tile layer options
+     *
+     * @example
+     * ```typescript
+     * sdk.addTileLayer({
+     *   id: 'my-tiles',
+     *   name: 'My Tile Layer',
+     *   url: 'https://{s}.tile.custom.com/{z}/{x}/{y}.png',
+     *   maxZoom: 19,
+     *   attribution: '© Custom Tiles'
+     * });
+     * ```
+     */
+    addTileLayer(options: AddTileLayerOptions): void;
+    /**
+     * Add a GeoJSON layer with optional styling and interaction
+     *
+     * @param options - GeoJSON layer options
+     *
+     * @example
+     * ```typescript
+     * sdk.addGeoJSONLayer({
+     *   id: 'polygons',
+     *   name: 'Custom Polygons',
+     *   data: myGeoJSON,
+     *   style: {
+     *     color: '#ff0000',
+     *     weight: 2,
+     *     fillOpacity: 0.3
+     *   },
+     *   onClick: (feature) => {
+     *     console.log('Clicked:', feature.properties);
+     *   }
+     * });
+     * ```
+     */
+    addGeoJSONLayer(options: AddGeoJSONLayerOptions): void;
+    /**
+     * Remove a layer by its ID
+     *
+     * @param layerId - Layer ID to remove
+     *
+     * @example
+     * ```typescript
+     * sdk.removeLayer('my-custom-layer');
+     * ```
+     */
+    removeLayer(layerId: string): void;
+    /**
+     * Toggle layer visibility
+     *
+     * @param layerId - Layer ID to toggle
+     * @param visible - Optional explicit visibility state
+     *
+     * @example
+     * ```typescript
+     * // Toggle visibility
+     * sdk.toggleLayer('my-layer');
+     *
+     * // Set explicit visibility
+     * sdk.toggleLayer('my-layer', true);  // Show
+     * sdk.toggleLayer('my-layer', false); // Hide
+     * ```
+     */
+    toggleLayer(layerId: string, visible?: boolean): void;
+    /**
+     * Get all current layers
+     *
+     * @returns Array of layer configurations
+     *
+     * @example
+     * ```typescript
+     * const layers = sdk.getLayers();
+     * console.log('Active layers:', layers.map(l => l.name));
+     * ```
+     */
+    getLayers(): LayerConfig[];
+    /**
+     * Get a specific layer by ID
+     *
+     * @param layerId - Layer ID to retrieve
+     * @returns Layer configuration or undefined
+     *
+     * @example
+     * ```typescript
+     * const layer = sdk.getLayer('my-layer');
+     * if (layer) {
+     *   console.log('Layer found:', layer.name);
+     * }
+     * ```
+     */
+    getLayer(layerId: string): LayerConfig | undefined;
+    /**
+     * Destroy the SDK instance and clean up
+     */
+    destroy(): void;
+}
+
+declare class SEPMapElement extends HTMLElement {
+    private sdk;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private buildConfig;
+    private parseFeatures;
+    private parseMapConfig;
+    private forwardEvents;
+    private toKebabCase;
+    get map(): SEPMapSDK | null;
+    selectAddress(idOrAddress: number | Parameters<SEPMapSDK['selectAddress']>[0]): Promise<Address | null> | undefined;
+    selectPerimeter(idOrPerimeter: string | Parameters<SEPMapSDK['selectPerimeter']>[0]): Promise<Perimeter | null> | undefined;
+    getSelection(): SelectionItem[];
+    clearSelection(): void;
+    setLanguage(locale: SupportedLocale): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sep-map': SEPMapElement;
+    }
+}
+
+export { AddressService, I18nManager, PerimeterService, SEPMapSDK, SEPMapSDK as default };
+export type { Address, DecisionTreeResult, FeatureConfig, MapConfig, Perimeter, SEPMapConfig, SEPMapRef, SelectionItem, SupportedLocale };