/* eslint-disable */
/* tslint:disable */
/**
 * This is an autogenerated file created by the Stencil compiler.
 * It contains typing information for all components that exist in this project.
 */
import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
import { Flavour } from "./types/flavour";
import { CssMode } from "./types/cssmode";
import { MapProviderDetail, VMapErrorDetail } from "./utils/events";
import { BuilderConfig } from "./utils/diff";
import { ColorMap as GeoStylerColorMap } from "geostyler-style";
import { Color } from "./components/v-map-layer-scatterplot/v-map-layer-scatterplot";
import { ResolvedStyle, StyleEvent, StyleFormat } from "./types/styling";
export { Flavour } from "./types/flavour";
export { CssMode } from "./types/cssmode";
export { MapProviderDetail, VMapErrorDetail } from "./utils/events";
export { BuilderConfig } from "./utils/diff";
export { ColorMap as GeoStylerColorMap } from "geostyler-style";
export { Color } from "./components/v-map-layer-scatterplot/v-map-layer-scatterplot";
export { ResolvedStyle, StyleEvent, StyleFormat } from "./types/styling";
export namespace Components {
    interface VMap {
        /**
          * Mittelpunkt der Karte im **WGS84**-Koordinatensystem. Erwartet [lon, lat] (Längengrad, Breitengrad).
          * @default [0, 0]
          * @example <v-map center="[11.5761, 48.1371]" zoom="12"></v-map>
         */
        "center": string;
        /**
          * Aktiviert ein „CSS-Only“-Rendering (z. B. für einfache Tests/Layouts). Bei `true` werden keine Provider initialisiert.
          * @default false
         */
        "cssMode": CssMode;
        /**
          * Zu verwendender Karten-Provider. Unterstützte Werte: "ol" | "leaflet" | "cesium" | "deck".
          * @default "ol"
          * @example <v-map flavour="leaflet"></v-map>
         */
        "flavour": Flavour;
        /**
          * Gibt zurück, ob der Karten-Provider initialisiert wurde und verwendet werden kann.
          * @returns Promise mit `true`, sobald der Provider bereit ist, sonst `false`.
         */
        "isMapProviderReady": () => Promise<boolean>;
        /**
          * Setzt Kartenzentrum und Zoom (optional animiert).
          * @param center [lon, lat] in WGS84
          * @param zoom Zoomstufe
          * @param options Zusätzliche Optionen (z. B. { animate: true, duration: 300 })
          * @example await mapEl.setView([7.1, 50.7], 10, { animate: true, duration: 400 });
         */
        "setView": (coordinates: [number, number], zoom: number) => Promise<void>;
        /**
          * Falls true, injiziert v-map automatisch die Import-Map.
          * @default true
         */
        "useDefaultImportMap": boolean;
        /**
          * Anfangs-Zoomstufe. Skala abhängig vom Provider (typisch 0–20).
          * @default 3
         */
        "zoom": number;
    }
    /**
     * A component that builds map configurations dynamically from JSON/YAML configuration scripts.
     */
    interface VMapBuilder {
        /**
          * Configuration object for the map builder. Can be any structure that will be normalized to BuilderConfig.
         */
        "mapconfig"?: unknown;
    }
    /**
     * `<v-map-error>` lauscht auf das `vmap-error` Event seiner Eltern-`<v-map>`
     * (oder einer per `for`-Attribut adressierten Karte) und rendert die Fehler
     * als kleine, opinionated gestylte Toast-Stapel innerhalb des Karten-Containers.
     * Damit können einfache HTML-Beispiele Fehler sichtbar machen, ohne eine
     * Zeile JavaScript zu schreiben.
     * @example ```html
     * <v-map flavour="ol">
     *   <v-map-error position="top-right" auto-dismiss="5000"></v-map-error>
     *   <v-map-layergroup group-title="Basiskarten" basemapid="OSM-BASE">
     *     <v-map-layer-osm id="OSM-BASE" label="OSM"></v-map-layer-osm>
     *   </v-map-layergroup>
     * </v-map>
     * ```
     */
    interface VMapError {
        /**
          * Auto-Dismiss-Zeit in Millisekunden. `0` deaktiviert das automatische Ausblenden — Toasts bleiben dann sichtbar, bis sie manuell geschlossen oder durch einen neueren Fehler aus dem Stapel gedrängt werden.
          * @default 5000
         */
        "autoDismiss": number;
        /**
          * ID der `<v-map>`-Karte, deren Fehler angezeigt werden sollen. Wenn nicht angegeben, hängt sich die Komponente an das nächste `<v-map>`-Vorfahrenelement im DOM-Baum.
         */
        "for"?: string;
        /**
          * Zusätzliches Logging in die Browser-Console. - `'none'` (Default): nur Toast-Anzeige, kein Console-Output - `'console'`: jeder Fehler wird zusätzlich mit `console.error` geloggt
          * @default 'none'
         */
        "log": LogMode;
        /**
          * Maximale Anzahl gleichzeitig sichtbarer Toasts. Ältere werden bei Überschreitung am oberen Ende des Stapels entfernt.
          * @default 3
         */
        "max": number;
        /**
          * Position des Toast-Stapels innerhalb des `<v-map>`-Containers.
          * @default 'top-right'
         */
        "position": ToastPosition;
    }
    interface VMapLayerGeojson {
        /**
          * Fill color for polygon geometries (CSS color value)
          * @default 'rgba(0,100,255,0.3)'
         */
        "fillColor"?: string;
        /**
          * Fill opacity for polygon geometries (0-1)
          * @default 0.3
         */
        "fillOpacity"?: number;
        /**
          * Prop, die du intern nutzt/weiterverarbeitest
         */
        "geojson"?: string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Returns the internal layer ID used by the map provider.
         */
        "getLayerId": () => Promise<string>;
        /**
          * Icon size as [width, height] in pixels (comma-separated string like "32,32")
          * @default "32,32"
         */
        "iconSize"?: string;
        /**
          * Icon URL for point features (alternative to pointColor/pointRadius)
         */
        "iconUrl"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität der geojson-Kacheln (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Point color for point geometries (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "pointColor"?: string;
        /**
          * Point radius for point geometries in pixels
          * @default 6
         */
        "pointRadius"?: number;
        /**
          * Stroke color for lines and polygon outlines (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "strokeColor"?: string;
        /**
          * Stroke opacity (0-1)
          * @default 1
         */
        "strokeOpacity"?: number;
        /**
          * Stroke width in pixels
          * @default 2
         */
        "strokeWidth"?: number;
        /**
          * Text color for labels (CSS color value)
          * @default '#000000'
         */
        "textColor"?: string;
        /**
          * Text property name from feature properties to display as label
         */
        "textProperty"?: string;
        /**
          * Text size for labels in pixels
          * @default 12
         */
        "textSize"?: number;
        /**
          * URL to fetch GeoJSON data from. Alternative to providing data via slot.
          * @default null
         */
        "url": string | null;
        /**
          * Whether the layer is visible on the map.
          * @default true
         */
        "visible": boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 1000
         */
        "zIndex": number;
    }
    interface VMapLayerGeotiff {
        /**
          * ColorMap für die Visualisierung (kann entweder ein vordefinierter Name oder eine GeoStyler ColorMap sein).
          * @default null
         */
        "colorMap"?: string | GeoStylerColorMap;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Returns the internal layer ID used by the map provider.
         */
        "getLayerId": () => Promise<string>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * NoData Values to discard (overriding any nodata values in the metadata).
          * @default null
         */
        "nodata"?: number;
        /**
          * Opazität der GeoTIFF-Kacheln (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * URL to the GeoTIFF file to be displayed on the map.
          * @default null
         */
        "url": string;
        /**
          * Value range for colormap normalization [min, max].
          * @default null
         */
        "valueRange"?: [number, number];
        /**
          * Sichtbarkeit des Layers
          * @default true
         */
        "visible": boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 100
         */
        "zIndex": number;
    }
    /**
     * Google Maps Basemap Layer
     */
    interface VMapLayerGoogle {
        /**
          * Google Maps API-Schlüssel.
          * @example <v-map-layer-google api-key="YOUR_KEY"></v-map-layer-google>
         */
        "apiKey"?: string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Sprach-Lokalisierung (BCP-47, z. B. "de", "en-US").
          * @default "en"
         */
        "language"?: string;
        /**
          * Google Maps libraries to load (comma-separated string).
          * @example "geometry,places,drawing"
         */
        "libraries"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Karten-Typ: "roadmap" | "satellite" | "hybrid" | "terrain".
          * @default "roadmap"
         */
        "mapType": | 'roadmap'
    | 'satellite'
    | 'terrain'
    | 'hybrid';
        /**
          * Maximum zoom level for the layer.
         */
        "maxZoom"?: number;
        /**
          * Opazität des Layers (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Region-Bias (ccTLD/Region-Code, z. B. "DE", "US"). Beeinflusst Labels/Suchergebnisse.
         */
        "region"?: string;
        /**
          * Scale factor for tile display.
          * @default "scaleFactor1x"
         */
        "scale"?: 'scaleFactor1x' | 'scaleFactor2x' | 'scaleFactor4x';
        /**
          * Custom styles for the Google Map (JSON array of styling objects). Can be passed as JSON string or array.
         */
        "styles"?: Record<string, unknown>[] | string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible": boolean;
    }
    interface VMapLayerOsm {
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Returns the internal layer ID used by the map provider.
         */
        "getLayerId": () => Promise<string>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität der OSM-Kacheln (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Base URL for OpenStreetMap tile server. Defaults to the standard OSM tile server.
          * @default 'https://tile.openstreetmap.org'
         */
        "url": string;
        /**
          * Sichtbarkeit des Layers
          * @default true
         */
        "visible": boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 10
         */
        "zIndex": number;
    }
    interface VMapLayerScatterplot {
        /**
          * Datenquelle für Punkte. Erwartet Objekte mit mindestens einer Position in [lon, lat]. Zusätzliche Felder sind erlaubt.
         */
        "data"?: string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Funktion zur Bestimmung der Füllfarbe je Punkt. Rückgabe z. B. [r,g,b] oder CSS-Farbe (providerabhängig).
          * @default '#3388ff'
         */
        "getFillColor": Color;
        /**
          * Funktion/konstanter Wert für den Punkt-Radius.
          * @default 4
         */
        "getRadius": number;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Globale Opazität (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Optionaler Remote-Pfad für JSON/CSV/GeoJSON, der zu `data` geladen wird.
         */
        "url"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible": boolean;
    }
    interface VMapLayerTerrain {
        /**
          * Basisfarbe für das Terrain. Erwartet Hex oder RGB (z. B. '#ff0000' oder '255,0,0').
         */
        "color"?: string;
        /**
          * URL zu Höhenraster im Heightmap-Format (z. B. GeoTIFF oder PNG Heightmap).
         */
        "elevationData": string;
        /**
          * JSON-Repräsentation eines Elevation-Decoders (z. B. '{"r":1,"g":1,"b":1,"offset":0}').
         */
        "elevationDecoder"?: string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Liefert `true`, sobald das Terrain-Layer initialisiert wurde.
         */
        "isReady": () => Promise<boolean>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Maximale Zoomstufe für das Terrain.
         */
        "maxZoom"?: number;
        /**
          * Fehler-Toleranz für das Mesh (wird an TerrainRenderer durchgereicht).
         */
        "meshMaxError"?: number;
        /**
          * Minimale Zoomstufe für das Terrain.
         */
        "minZoom"?: number;
        /**
          * Opazität des Layers.
          * @default 1
         */
        "opacity": number;
        /**
          * Optionale Textur (RGB) für das Terrain.
         */
        "texture"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible": boolean;
        /**
          * Darstellung des Mesh als Drahtgitter.
         */
        "wireframe"?: boolean;
        /**
          * Z-Index für die Darstellung.
          * @default 1000
         */
        "zIndex": number;
    }
    interface VMapLayerTerrainGeotiff {
        /**
          * Color for the terrain (if no texture is provided). [r, g, b] with values 0-255.
          * @default [255, 255, 255]
         */
        "color"?: [number, number, number];
        /**
          * ColorMap for elevation data visualization. Only relevant when no texture is set.
          * @default null
         */
        "colorMap"?: string | GeoStylerColorMap;
        /**
          * Elevation exaggeration factor.
          * @default 1.0
         */
        "elevationScale"?: number;
        /**
          * Erzwingt die Verwendung der projection-Prop, ignoriert GeoKeys
          * @default false
         */
        "forceProjection"?: boolean;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Returns the internal layer ID used by the map provider.
         */
        "getLayerId": () => Promise<string>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Maximum zoom level.
          * @default 24
         */
        "maxZoom"?: number;
        /**
          * Mesh error tolerance in meters (Martini). Smaller values = more detailed mesh, but slower.
          * @default 4.0
         */
        "meshMaxError"?: number;
        /**
          * Minimum zoom level.
          * @default 0
         */
        "minZoom"?: number;
        /**
          * NoData value to discard (overriding any nodata values in the metadata).
          * @default null
         */
        "nodata"?: number;
        /**
          * Opacity of the terrain layer (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Quell-Projektion des GeoTIFF (z. B. "EPSG:32632" oder proj4-String)
          * @default null
         */
        "projection"?: string;
        /**
          * Rendering mode for GeoTIFF terrain.
          * @default terrain
         */
        "renderMode"?: 'terrain' | 'colormap';
        /**
          * Optional texture URL (can be an image or tile URL).
          * @default null
         */
        "texture"?: string;
        /**
          * Tile size in pixels.
          * @default 256
         */
        "tileSize"?: number;
        /**
          * URL to the GeoTIFF file containing elevation data.
          * @default null
         */
        "url": string;
        /**
          * Value range for colormap normalization [min, max].
          * @default null
         */
        "valueRange"?: [number, number];
        /**
          * Sichtbarkeit des Layers
          * @default true
         */
        "visible": boolean;
        /**
          * Enable wireframe mode (show only mesh lines).
          * @default false
         */
        "wireframe"?: boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 100
         */
        "zIndex": number;
    }
    interface VMapLayerTile3d {
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Indicates whether the tileset has been initialised and added to the map.
         */
        "isReady": () => Promise<boolean>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Global opacity factor (0-1).
          * @default 1
         */
        "opacity": number;
        /**
          * Optional JSON string or object with Cesium3DTileset options.
         */
        "tilesetOptions"?: string | Record<string, unknown>;
        /**
          * URL pointing to the Cesium 3D Tileset.
         */
        "url": string;
        /**
          * Whether the tileset should be visible.
          * @default true
         */
        "visible": boolean;
        /**
          * Z-index used for ordering tilesets.
          * @default 1000
         */
        "zIndex": number;
    }
    interface VMapLayerWcs {
        /**
          * Coverage-Name/ID.
         */
        "coverageName": string;
        /**
          * Ausgabeformat, z. B. image/tiff.
          * @default 'image/tiff'
         */
        "format": string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Gibt `true` zurück, sobald der Layer initialisiert wurde.
         */
        "isReady": () => Promise<boolean>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Zusätzliche Parameter als JSON-String.
         */
        "params"?: string;
        /**
          * Projektion (Projection) für die Quelle.
         */
        "projection"?: string;
        /**
          * Auflösungen als JSON-Array, z. B. [1000,500].
         */
        "resolutions"?: string;
        /**
          * Basis-URL des WCS-Dienstes.
         */
        "url": string;
        /**
          * WCS-Version.
          * @default '1.1.0'
         */
        "version": string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible": boolean;
        /**
          * Z-Index für die Darstellung.
          * @default 1000
         */
        "zIndex": number;
    }
    interface VMapLayerWfs {
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Gibt `true` zurück, sobald der Layer initialisiert wurde.
         */
        "isReady": () => Promise<boolean>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Ausgabeformat, z. B. application/json.
          * @default 'application/json'
         */
        "outputFormat": string;
        /**
          * Zusätzliche Parameter als JSON-String.
         */
        "params"?: string;
        /**
          * Ziel-Referenzsystem, Standard EPSG:3857.
          * @default 'EPSG:3857'
         */
        "srsName": string;
        /**
          * Feature-Typ (typeName) des WFS.
         */
        "typeName": string;
        /**
          * WFS Endpunkt (z. B. https://server/wfs).
         */
        "url": string;
        /**
          * WFS Version, Standard 1.1.0.
          * @default '1.1.0'
         */
        "version": string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible": boolean;
        /**
          * Z-Index für Rendering.
          * @default 1000
         */
        "zIndex": number;
    }
    interface VMapLayerWkt {
        /**
          * Fill color for polygon geometries (CSS color value)
          * @default 'rgba(0,100,255,0.3)'
         */
        "fillColor"?: string;
        /**
          * Fill opacity for polygon geometries (0-1)
          * @default 0.3
         */
        "fillOpacity"?: number;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Returns the internal layer ID used by the map provider.
         */
        "getLayerId": () => Promise<string>;
        /**
          * Icon size as [width, height] in pixels (comma-separated string like "32,32")
          * @default "32,32"
         */
        "iconSize"?: string;
        /**
          * Icon URL for point features (alternative to pointColor/pointRadius)
         */
        "iconUrl"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Globale Opazität (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Point color for point geometries (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "pointColor"?: string;
        /**
          * Point radius for point geometries in pixels
          * @default 6
         */
        "pointRadius"?: number;
        /**
          * Stroke color for lines and polygon outlines (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "strokeColor"?: string;
        /**
          * Stroke opacity (0-1)
          * @default 1
         */
        "strokeOpacity"?: number;
        /**
          * Stroke width in pixels
          * @default 2
         */
        "strokeWidth"?: number;
        /**
          * Text color for labels (CSS color value)
          * @default '#000000'
         */
        "textColor"?: string;
        /**
          * Text property name from feature properties to display as label
         */
        "textProperty"?: string;
        /**
          * Text size for labels in pixels
          * @default 12
         */
        "textSize"?: number;
        /**
          * URL, von der eine WKT-Geometrie geladen wird (alternativ zu `wkt`).
         */
        "url"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible": boolean;
        /**
          * WKT-Geometrie (z. B. "POINT(11.57 48.14)" oder "POLYGON((...))").
         */
        "wkt"?: string;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 1000
         */
        "zIndex": number;
    }
    /**
     * OGC WMS Layer
     */
    interface VMapLayerWms {
        /**
          * Bildformat des GetMap-Requests.
          * @default "image/png"
         */
        "format": string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Kommagetrennte Layer-Namen (z. B. "topp:states").
         */
        "layers": string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Globale Opazität des WMS-Layers (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * WMS-`STYLES` Parameter (kommagetrennt).
          * @default ""
         */
        "styles"?: string;
        /**
          * Tiled/geslicete Requests verwenden (falls Server unterstützt).
          * @default true
         */
        "tiled": boolean;
        /**
          * Transparente Kacheln anfordern.
          * @default true
         */
        "transparent": boolean;
        /**
          * Basis-URL des WMS-Dienstes (GetMap-Endpunkt ohne Query-Parameter).
         */
        "url": string;
        /**
          * Sichtbarkeit des WMS-Layers.
          * @default true
         */
        "visible": boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 10
         */
        "zIndex": number;
    }
    /**
     * XYZ Tile Layer
     */
    interface VMapLayerXyz {
        /**
          * Attributions-/Copyright-Text (HTML erlaubt).
         */
        "attributions"?: string;
        /**
          * Returns the last error detail, if any.
         */
        "getError": () => Promise<VMapErrorDetail | undefined>;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Maximaler Zoomlevel, den der Tile-Server liefert.
          * @default 19
         */
        "maxZoom"?: number;
        /**
          * Opazität (0–1).
          * @default 1
         */
        "opacity": number;
        /**
          * Subdomains für parallele Tile-Anfragen (z. B. "a,b,c").
         */
        "subdomains"?: string;
        /**
          * Größe einer Kachel in Pixeln.
          * @default 256
         */
        "tileSize"?: number;
        /**
          * URL-Template für Kacheln, z. B. "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png".
         */
        "url": string;
        /**
          * Sichtbarkeit des XYZ-Layers.
          * @default true
         */
        "visible": boolean;
    }
    interface VMapLayercontrol {
        /**
          * ID der zu steuernden Karte (DOM-Element mit dieser id)
         */
        "for": string;
    }
    interface VMapLayergroup {
        /**
          * Base map identifier for this layer group. When set, layers in this group will be treated as base map layers.
          * @default null
         */
        "basemapid": string | null;
        /**
          * Returns the internal group identifier used by the map provider.
         */
        "getGroupId": () => Promise<string>;
        /**
          * Globale Opazität (0–1) für alle Kinder.
          * @default 1
         */
        "opacity": number;
        /**
          * Sichtbarkeit der gesamten Gruppe.
          * @default true
         */
        "visible": boolean;
    }
    interface VMapStyle {
        /**
          * Whether to automatically apply the style when loaded.
          * @default true
         */
        "autoApply": boolean;
        /**
          * Inline style content as string (alternative to src).
         */
        "content"?: string;
        /**
          * The styling format to parse (supports 'sld', 'mapbox-gl', 'qgis', 'lyrx', 'cesium-3d-tiles').
          * @default 'sld'
         */
        "format": StyleFormat;
        /**
          * Get the target layer IDs as array. async
         */
        "getLayerTargetIds": () => Promise<string[]>;
        /**
          * Get the currently parsed style.
         */
        "getStyle": () => Promise<ResolvedStyle | undefined>;
        /**
          * Target layer IDs to apply this style to. If not specified, applies to all compatible layers.
         */
        "layerTargets"?: string;
        /**
          * The style source - can be a URL to fetch from or inline SLD/style content.
         */
        "src"?: string;
    }
}
export interface VMapCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapElement;
}
export interface VMapBuilderCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapBuilderElement;
}
export interface VMapLayerGeotiffCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerGeotiffElement;
}
export interface VMapLayerGoogleCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerGoogleElement;
}
export interface VMapLayerOsmCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerOsmElement;
}
export interface VMapLayerScatterplotCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerScatterplotElement;
}
export interface VMapLayerTerrainGeotiffCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerTerrainGeotiffElement;
}
export interface VMapLayerTile3dCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerTile3dElement;
}
export interface VMapLayerWktCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerWktElement;
}
export interface VMapLayerWmsCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerWmsElement;
}
export interface VMapLayerXyzCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapLayerXyzElement;
}
export interface VMapStyleCustomEvent<T> extends CustomEvent<T> {
    detail: T;
    target: HTMLVMapStyleElement;
}
declare global {
    interface HTMLVMapElementEventMap {
        "mapProviderReady": MapProviderDetail;
    }
    interface HTMLVMapElement extends Components.VMap, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapElementEventMap>(type: K, listener: (this: HTMLVMapElement, ev: VMapCustomEvent<HTMLVMapElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapElementEventMap>(type: K, listener: (this: HTMLVMapElement, ev: VMapCustomEvent<HTMLVMapElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapElement: {
        prototype: HTMLVMapElement;
        new (): HTMLVMapElement;
    };
    interface HTMLVMapBuilderElementEventMap {
        "configReady": BuilderConfig;
        "configError": {
    message: string;
    errors?: string[];
  };
    }
    /**
     * A component that builds map configurations dynamically from JSON/YAML configuration scripts.
     */
    interface HTMLVMapBuilderElement extends Components.VMapBuilder, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapBuilderElementEventMap>(type: K, listener: (this: HTMLVMapBuilderElement, ev: VMapBuilderCustomEvent<HTMLVMapBuilderElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapBuilderElementEventMap>(type: K, listener: (this: HTMLVMapBuilderElement, ev: VMapBuilderCustomEvent<HTMLVMapBuilderElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapBuilderElement: {
        prototype: HTMLVMapBuilderElement;
        new (): HTMLVMapBuilderElement;
    };
    /**
     * `<v-map-error>` lauscht auf das `vmap-error` Event seiner Eltern-`<v-map>`
     * (oder einer per `for`-Attribut adressierten Karte) und rendert die Fehler
     * als kleine, opinionated gestylte Toast-Stapel innerhalb des Karten-Containers.
     * Damit können einfache HTML-Beispiele Fehler sichtbar machen, ohne eine
     * Zeile JavaScript zu schreiben.
     * @example ```html
     * <v-map flavour="ol">
     *   <v-map-error position="top-right" auto-dismiss="5000"></v-map-error>
     *   <v-map-layergroup group-title="Basiskarten" basemapid="OSM-BASE">
     *     <v-map-layer-osm id="OSM-BASE" label="OSM"></v-map-layer-osm>
     *   </v-map-layergroup>
     * </v-map>
     * ```
     */
    interface HTMLVMapErrorElement extends Components.VMapError, HTMLStencilElement {
    }
    var HTMLVMapErrorElement: {
        prototype: HTMLVMapErrorElement;
        new (): HTMLVMapErrorElement;
    };
    interface HTMLVMapLayerGeojsonElement extends Components.VMapLayerGeojson, HTMLStencilElement {
    }
    var HTMLVMapLayerGeojsonElement: {
        prototype: HTMLVMapLayerGeojsonElement;
        new (): HTMLVMapLayerGeojsonElement;
    };
    interface HTMLVMapLayerGeotiffElementEventMap {
        "ready": void;
    }
    interface HTMLVMapLayerGeotiffElement extends Components.VMapLayerGeotiff, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerGeotiffElementEventMap>(type: K, listener: (this: HTMLVMapLayerGeotiffElement, ev: VMapLayerGeotiffCustomEvent<HTMLVMapLayerGeotiffElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerGeotiffElementEventMap>(type: K, listener: (this: HTMLVMapLayerGeotiffElement, ev: VMapLayerGeotiffCustomEvent<HTMLVMapLayerGeotiffElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerGeotiffElement: {
        prototype: HTMLVMapLayerGeotiffElement;
        new (): HTMLVMapLayerGeotiffElement;
    };
    interface HTMLVMapLayerGoogleElementEventMap {
        "ready": void;
    }
    /**
     * Google Maps Basemap Layer
     */
    interface HTMLVMapLayerGoogleElement extends Components.VMapLayerGoogle, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerGoogleElementEventMap>(type: K, listener: (this: HTMLVMapLayerGoogleElement, ev: VMapLayerGoogleCustomEvent<HTMLVMapLayerGoogleElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerGoogleElementEventMap>(type: K, listener: (this: HTMLVMapLayerGoogleElement, ev: VMapLayerGoogleCustomEvent<HTMLVMapLayerGoogleElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerGoogleElement: {
        prototype: HTMLVMapLayerGoogleElement;
        new (): HTMLVMapLayerGoogleElement;
    };
    interface HTMLVMapLayerOsmElementEventMap {
        "ready": void;
    }
    interface HTMLVMapLayerOsmElement extends Components.VMapLayerOsm, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerOsmElementEventMap>(type: K, listener: (this: HTMLVMapLayerOsmElement, ev: VMapLayerOsmCustomEvent<HTMLVMapLayerOsmElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerOsmElementEventMap>(type: K, listener: (this: HTMLVMapLayerOsmElement, ev: VMapLayerOsmCustomEvent<HTMLVMapLayerOsmElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerOsmElement: {
        prototype: HTMLVMapLayerOsmElement;
        new (): HTMLVMapLayerOsmElement;
    };
    interface HTMLVMapLayerScatterplotElementEventMap {
        "ready": void;
    }
    interface HTMLVMapLayerScatterplotElement extends Components.VMapLayerScatterplot, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerScatterplotElementEventMap>(type: K, listener: (this: HTMLVMapLayerScatterplotElement, ev: VMapLayerScatterplotCustomEvent<HTMLVMapLayerScatterplotElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerScatterplotElementEventMap>(type: K, listener: (this: HTMLVMapLayerScatterplotElement, ev: VMapLayerScatterplotCustomEvent<HTMLVMapLayerScatterplotElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerScatterplotElement: {
        prototype: HTMLVMapLayerScatterplotElement;
        new (): HTMLVMapLayerScatterplotElement;
    };
    interface HTMLVMapLayerTerrainElement extends Components.VMapLayerTerrain, HTMLStencilElement {
    }
    var HTMLVMapLayerTerrainElement: {
        prototype: HTMLVMapLayerTerrainElement;
        new (): HTMLVMapLayerTerrainElement;
    };
    interface HTMLVMapLayerTerrainGeotiffElementEventMap {
        "ready": void;
    }
    interface HTMLVMapLayerTerrainGeotiffElement extends Components.VMapLayerTerrainGeotiff, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerTerrainGeotiffElementEventMap>(type: K, listener: (this: HTMLVMapLayerTerrainGeotiffElement, ev: VMapLayerTerrainGeotiffCustomEvent<HTMLVMapLayerTerrainGeotiffElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerTerrainGeotiffElementEventMap>(type: K, listener: (this: HTMLVMapLayerTerrainGeotiffElement, ev: VMapLayerTerrainGeotiffCustomEvent<HTMLVMapLayerTerrainGeotiffElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerTerrainGeotiffElement: {
        prototype: HTMLVMapLayerTerrainGeotiffElement;
        new (): HTMLVMapLayerTerrainGeotiffElement;
    };
    interface HTMLVMapLayerTile3dElementEventMap {
        "ready": void;
    }
    interface HTMLVMapLayerTile3dElement extends Components.VMapLayerTile3d, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerTile3dElementEventMap>(type: K, listener: (this: HTMLVMapLayerTile3dElement, ev: VMapLayerTile3dCustomEvent<HTMLVMapLayerTile3dElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerTile3dElementEventMap>(type: K, listener: (this: HTMLVMapLayerTile3dElement, ev: VMapLayerTile3dCustomEvent<HTMLVMapLayerTile3dElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerTile3dElement: {
        prototype: HTMLVMapLayerTile3dElement;
        new (): HTMLVMapLayerTile3dElement;
    };
    interface HTMLVMapLayerWcsElement extends Components.VMapLayerWcs, HTMLStencilElement {
    }
    var HTMLVMapLayerWcsElement: {
        prototype: HTMLVMapLayerWcsElement;
        new (): HTMLVMapLayerWcsElement;
    };
    interface HTMLVMapLayerWfsElement extends Components.VMapLayerWfs, HTMLStencilElement {
    }
    var HTMLVMapLayerWfsElement: {
        prototype: HTMLVMapLayerWfsElement;
        new (): HTMLVMapLayerWfsElement;
    };
    interface HTMLVMapLayerWktElementEventMap {
        "ready": void;
    }
    interface HTMLVMapLayerWktElement extends Components.VMapLayerWkt, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerWktElementEventMap>(type: K, listener: (this: HTMLVMapLayerWktElement, ev: VMapLayerWktCustomEvent<HTMLVMapLayerWktElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerWktElementEventMap>(type: K, listener: (this: HTMLVMapLayerWktElement, ev: VMapLayerWktCustomEvent<HTMLVMapLayerWktElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerWktElement: {
        prototype: HTMLVMapLayerWktElement;
        new (): HTMLVMapLayerWktElement;
    };
    interface HTMLVMapLayerWmsElementEventMap {
        "ready": void;
    }
    /**
     * OGC WMS Layer
     */
    interface HTMLVMapLayerWmsElement extends Components.VMapLayerWms, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerWmsElementEventMap>(type: K, listener: (this: HTMLVMapLayerWmsElement, ev: VMapLayerWmsCustomEvent<HTMLVMapLayerWmsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerWmsElementEventMap>(type: K, listener: (this: HTMLVMapLayerWmsElement, ev: VMapLayerWmsCustomEvent<HTMLVMapLayerWmsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerWmsElement: {
        prototype: HTMLVMapLayerWmsElement;
        new (): HTMLVMapLayerWmsElement;
    };
    interface HTMLVMapLayerXyzElementEventMap {
        "ready": void;
    }
    /**
     * XYZ Tile Layer
     */
    interface HTMLVMapLayerXyzElement extends Components.VMapLayerXyz, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapLayerXyzElementEventMap>(type: K, listener: (this: HTMLVMapLayerXyzElement, ev: VMapLayerXyzCustomEvent<HTMLVMapLayerXyzElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapLayerXyzElementEventMap>(type: K, listener: (this: HTMLVMapLayerXyzElement, ev: VMapLayerXyzCustomEvent<HTMLVMapLayerXyzElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapLayerXyzElement: {
        prototype: HTMLVMapLayerXyzElement;
        new (): HTMLVMapLayerXyzElement;
    };
    interface HTMLVMapLayercontrolElement extends Components.VMapLayercontrol, HTMLStencilElement {
    }
    var HTMLVMapLayercontrolElement: {
        prototype: HTMLVMapLayercontrolElement;
        new (): HTMLVMapLayercontrolElement;
    };
    interface HTMLVMapLayergroupElement extends Components.VMapLayergroup, HTMLStencilElement {
    }
    var HTMLVMapLayergroupElement: {
        prototype: HTMLVMapLayergroupElement;
        new (): HTMLVMapLayergroupElement;
    };
    interface HTMLVMapStyleElementEventMap {
        "styleReady": StyleEvent;
        "styleError": Error;
    }
    interface HTMLVMapStyleElement extends Components.VMapStyle, HTMLStencilElement {
        addEventListener<K extends keyof HTMLVMapStyleElementEventMap>(type: K, listener: (this: HTMLVMapStyleElement, ev: VMapStyleCustomEvent<HTMLVMapStyleElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener<K extends keyof HTMLVMapStyleElementEventMap>(type: K, listener: (this: HTMLVMapStyleElement, ev: VMapStyleCustomEvent<HTMLVMapStyleElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
    var HTMLVMapStyleElement: {
        prototype: HTMLVMapStyleElement;
        new (): HTMLVMapStyleElement;
    };
    interface HTMLElementTagNameMap {
        "v-map": HTMLVMapElement;
        "v-map-builder": HTMLVMapBuilderElement;
        "v-map-error": HTMLVMapErrorElement;
        "v-map-layer-geojson": HTMLVMapLayerGeojsonElement;
        "v-map-layer-geotiff": HTMLVMapLayerGeotiffElement;
        "v-map-layer-google": HTMLVMapLayerGoogleElement;
        "v-map-layer-osm": HTMLVMapLayerOsmElement;
        "v-map-layer-scatterplot": HTMLVMapLayerScatterplotElement;
        "v-map-layer-terrain": HTMLVMapLayerTerrainElement;
        "v-map-layer-terrain-geotiff": HTMLVMapLayerTerrainGeotiffElement;
        "v-map-layer-tile3d": HTMLVMapLayerTile3dElement;
        "v-map-layer-wcs": HTMLVMapLayerWcsElement;
        "v-map-layer-wfs": HTMLVMapLayerWfsElement;
        "v-map-layer-wkt": HTMLVMapLayerWktElement;
        "v-map-layer-wms": HTMLVMapLayerWmsElement;
        "v-map-layer-xyz": HTMLVMapLayerXyzElement;
        "v-map-layercontrol": HTMLVMapLayercontrolElement;
        "v-map-layergroup": HTMLVMapLayergroupElement;
        "v-map-style": HTMLVMapStyleElement;
    }
}
declare namespace LocalJSX {
    type OneOf<K extends string, PropT, AttrT = PropT> = { [P in K]: PropT } & { [P in `attr:${K}` | `prop:${K}`]?: never } | { [P in `attr:${K}`]: AttrT } & { [P in K | `prop:${K}`]?: never } | { [P in `prop:${K}`]: PropT } & { [P in K | `attr:${K}`]?: never };

    interface VMap {
        /**
          * Mittelpunkt der Karte im **WGS84**-Koordinatensystem. Erwartet [lon, lat] (Längengrad, Breitengrad).
          * @default [0, 0]
          * @example <v-map center="[11.5761, 48.1371]" zoom="12"></v-map>
         */
        "center"?: string;
        /**
          * Aktiviert ein „CSS-Only“-Rendering (z. B. für einfache Tests/Layouts). Bei `true` werden keine Provider initialisiert.
          * @default false
         */
        "cssMode"?: CssMode;
        /**
          * Zu verwendender Karten-Provider. Unterstützte Werte: "ol" | "leaflet" | "cesium" | "deck".
          * @default "ol"
          * @example <v-map flavour="leaflet"></v-map>
         */
        "flavour"?: Flavour;
        /**
          * Wird ausgelöst, sobald der Karten-Provider initialisiert wurde und Layers entgegennimmt. `detail` enthält `{ provider, flavour }`.
          * @event mapProviderReady
         */
        "onMapProviderReady"?: (event: VMapCustomEvent<MapProviderDetail>) => void;
        /**
          * Falls true, injiziert v-map automatisch die Import-Map.
          * @default true
         */
        "useDefaultImportMap"?: boolean;
        /**
          * Anfangs-Zoomstufe. Skala abhängig vom Provider (typisch 0–20).
          * @default 3
         */
        "zoom"?: number;
    }
    /**
     * A component that builds map configurations dynamically from JSON/YAML configuration scripts.
     */
    interface VMapBuilder {
        /**
          * Configuration object for the map builder. Can be any structure that will be normalized to BuilderConfig.
         */
        "mapconfig"?: unknown;
        /**
          * Event emitted when there is an error parsing the map configuration.
         */
        "onConfigError"?: (event: VMapBuilderCustomEvent<{
    message: string;
    errors?: string[];
  }>) => void;
        /**
          * Event emitted when the map configuration has been successfully parsed and is ready to use.
         */
        "onConfigReady"?: (event: VMapBuilderCustomEvent<BuilderConfig>) => void;
    }
    /**
     * `<v-map-error>` lauscht auf das `vmap-error` Event seiner Eltern-`<v-map>`
     * (oder einer per `for`-Attribut adressierten Karte) und rendert die Fehler
     * als kleine, opinionated gestylte Toast-Stapel innerhalb des Karten-Containers.
     * Damit können einfache HTML-Beispiele Fehler sichtbar machen, ohne eine
     * Zeile JavaScript zu schreiben.
     * @example ```html
     * <v-map flavour="ol">
     *   <v-map-error position="top-right" auto-dismiss="5000"></v-map-error>
     *   <v-map-layergroup group-title="Basiskarten" basemapid="OSM-BASE">
     *     <v-map-layer-osm id="OSM-BASE" label="OSM"></v-map-layer-osm>
     *   </v-map-layergroup>
     * </v-map>
     * ```
     */
    interface VMapError {
        /**
          * Auto-Dismiss-Zeit in Millisekunden. `0` deaktiviert das automatische Ausblenden — Toasts bleiben dann sichtbar, bis sie manuell geschlossen oder durch einen neueren Fehler aus dem Stapel gedrängt werden.
          * @default 5000
         */
        "autoDismiss"?: number;
        /**
          * ID der `<v-map>`-Karte, deren Fehler angezeigt werden sollen. Wenn nicht angegeben, hängt sich die Komponente an das nächste `<v-map>`-Vorfahrenelement im DOM-Baum.
         */
        "for"?: string;
        /**
          * Zusätzliches Logging in die Browser-Console. - `'none'` (Default): nur Toast-Anzeige, kein Console-Output - `'console'`: jeder Fehler wird zusätzlich mit `console.error` geloggt
          * @default 'none'
         */
        "log"?: LogMode;
        /**
          * Maximale Anzahl gleichzeitig sichtbarer Toasts. Ältere werden bei Überschreitung am oberen Ende des Stapels entfernt.
          * @default 3
         */
        "max"?: number;
        /**
          * Position des Toast-Stapels innerhalb des `<v-map>`-Containers.
          * @default 'top-right'
         */
        "position"?: ToastPosition;
    }
    interface VMapLayerGeojson {
        /**
          * Fill color for polygon geometries (CSS color value)
          * @default 'rgba(0,100,255,0.3)'
         */
        "fillColor"?: string;
        /**
          * Fill opacity for polygon geometries (0-1)
          * @default 0.3
         */
        "fillOpacity"?: number;
        /**
          * Prop, die du intern nutzt/weiterverarbeitest
         */
        "geojson"?: string;
        /**
          * Icon size as [width, height] in pixels (comma-separated string like "32,32")
          * @default "32,32"
         */
        "iconSize"?: string;
        /**
          * Icon URL for point features (alternative to pointColor/pointRadius)
         */
        "iconUrl"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität der geojson-Kacheln (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Point color for point geometries (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "pointColor"?: string;
        /**
          * Point radius for point geometries in pixels
          * @default 6
         */
        "pointRadius"?: number;
        /**
          * Stroke color for lines and polygon outlines (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "strokeColor"?: string;
        /**
          * Stroke opacity (0-1)
          * @default 1
         */
        "strokeOpacity"?: number;
        /**
          * Stroke width in pixels
          * @default 2
         */
        "strokeWidth"?: number;
        /**
          * Text color for labels (CSS color value)
          * @default '#000000'
         */
        "textColor"?: string;
        /**
          * Text property name from feature properties to display as label
         */
        "textProperty"?: string;
        /**
          * Text size for labels in pixels
          * @default 12
         */
        "textSize"?: number;
        /**
          * URL to fetch GeoJSON data from. Alternative to providing data via slot.
          * @default null
         */
        "url"?: string | null;
        /**
          * Whether the layer is visible on the map.
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 1000
         */
        "zIndex"?: number;
    }
    interface VMapLayerGeotiff {
        /**
          * ColorMap für die Visualisierung (kann entweder ein vordefinierter Name oder eine GeoStyler ColorMap sein).
          * @default null
         */
        "colorMap"?: string | GeoStylerColorMap;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * NoData Values to discard (overriding any nodata values in the metadata).
          * @default null
         */
        "nodata"?: number;
        /**
          * Wird ausgelöst, wenn der GeoTIFF-Layer bereit ist.
          * @event ready
         */
        "onReady"?: (event: VMapLayerGeotiffCustomEvent<void>) => void;
        /**
          * Opazität der GeoTIFF-Kacheln (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * URL to the GeoTIFF file to be displayed on the map.
          * @default null
         */
        "url"?: string;
        /**
          * Value range for colormap normalization [min, max].
          * @default null
         */
        "valueRange"?: [number, number];
        /**
          * Sichtbarkeit des Layers
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 100
         */
        "zIndex"?: number;
    }
    /**
     * Google Maps Basemap Layer
     */
    interface VMapLayerGoogle {
        /**
          * Google Maps API-Schlüssel.
          * @example <v-map-layer-google api-key="YOUR_KEY"></v-map-layer-google>
         */
        "apiKey"?: string;
        /**
          * Sprach-Lokalisierung (BCP-47, z. B. "de", "en-US").
          * @default "en"
         */
        "language"?: string;
        /**
          * Google Maps libraries to load (comma-separated string).
          * @example "geometry,places,drawing"
         */
        "libraries"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Karten-Typ: "roadmap" | "satellite" | "hybrid" | "terrain".
          * @default "roadmap"
         */
        "mapType"?: | 'roadmap'
    | 'satellite'
    | 'terrain'
    | 'hybrid';
        /**
          * Maximum zoom level for the layer.
         */
        "maxZoom"?: number;
        /**
          * Signalisiert, dass der Google-Layer bereit ist. `detail` enthält Metadaten.
          * @event ready
         */
        "onReady"?: (event: VMapLayerGoogleCustomEvent<void>) => void;
        /**
          * Opazität des Layers (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Region-Bias (ccTLD/Region-Code, z. B. "DE", "US"). Beeinflusst Labels/Suchergebnisse.
         */
        "region"?: string;
        /**
          * Scale factor for tile display.
          * @default "scaleFactor1x"
         */
        "scale"?: 'scaleFactor1x' | 'scaleFactor2x' | 'scaleFactor4x';
        /**
          * Custom styles for the Google Map (JSON array of styling objects). Can be passed as JSON string or array.
         */
        "styles"?: Record<string, unknown>[] | string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible"?: boolean;
    }
    interface VMapLayerOsm {
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Wird ausgelöst, wenn der OSM-Layer bereit ist.
          * @event ready
         */
        "onReady"?: (event: VMapLayerOsmCustomEvent<void>) => void;
        /**
          * Opazität der OSM-Kacheln (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Base URL for OpenStreetMap tile server. Defaults to the standard OSM tile server.
          * @default 'https://tile.openstreetmap.org'
         */
        "url"?: string;
        /**
          * Sichtbarkeit des Layers
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 10
         */
        "zIndex"?: number;
    }
    interface VMapLayerScatterplot {
        /**
          * Datenquelle für Punkte. Erwartet Objekte mit mindestens einer Position in [lon, lat]. Zusätzliche Felder sind erlaubt.
         */
        "data"?: string;
        /**
          * Funktion zur Bestimmung der Füllfarbe je Punkt. Rückgabe z. B. [r,g,b] oder CSS-Farbe (providerabhängig).
          * @default '#3388ff'
         */
        "getFillColor"?: Color;
        /**
          * Funktion/konstanter Wert für den Punkt-Radius.
          * @default 4
         */
        "getRadius"?: number;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Wird ausgelöst, sobald der Scatterplot registriert wurde.
          * @event ready
         */
        "onReady"?: (event: VMapLayerScatterplotCustomEvent<void>) => void;
        /**
          * Globale Opazität (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Optionaler Remote-Pfad für JSON/CSV/GeoJSON, der zu `data` geladen wird.
         */
        "url"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible"?: boolean;
    }
    interface VMapLayerTerrain {
        /**
          * Basisfarbe für das Terrain. Erwartet Hex oder RGB (z. B. '#ff0000' oder '255,0,0').
         */
        "color"?: string;
        /**
          * URL zu Höhenraster im Heightmap-Format (z. B. GeoTIFF oder PNG Heightmap).
         */
        "elevationData": string;
        /**
          * JSON-Repräsentation eines Elevation-Decoders (z. B. '{"r":1,"g":1,"b":1,"offset":0}').
         */
        "elevationDecoder"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Maximale Zoomstufe für das Terrain.
         */
        "maxZoom"?: number;
        /**
          * Fehler-Toleranz für das Mesh (wird an TerrainRenderer durchgereicht).
         */
        "meshMaxError"?: number;
        /**
          * Minimale Zoomstufe für das Terrain.
         */
        "minZoom"?: number;
        /**
          * Opazität des Layers.
          * @default 1
         */
        "opacity"?: number;
        /**
          * Optionale Textur (RGB) für das Terrain.
         */
        "texture"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible"?: boolean;
        /**
          * Darstellung des Mesh als Drahtgitter.
         */
        "wireframe"?: boolean;
        /**
          * Z-Index für die Darstellung.
          * @default 1000
         */
        "zIndex"?: number;
    }
    interface VMapLayerTerrainGeotiff {
        /**
          * Color for the terrain (if no texture is provided). [r, g, b] with values 0-255.
          * @default [255, 255, 255]
         */
        "color"?: [number, number, number];
        /**
          * ColorMap for elevation data visualization. Only relevant when no texture is set.
          * @default null
         */
        "colorMap"?: string | GeoStylerColorMap;
        /**
          * Elevation exaggeration factor.
          * @default 1.0
         */
        "elevationScale"?: number;
        /**
          * Erzwingt die Verwendung der projection-Prop, ignoriert GeoKeys
          * @default false
         */
        "forceProjection"?: boolean;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Maximum zoom level.
          * @default 24
         */
        "maxZoom"?: number;
        /**
          * Mesh error tolerance in meters (Martini). Smaller values = more detailed mesh, but slower.
          * @default 4.0
         */
        "meshMaxError"?: number;
        /**
          * Minimum zoom level.
          * @default 0
         */
        "minZoom"?: number;
        /**
          * NoData value to discard (overriding any nodata values in the metadata).
          * @default null
         */
        "nodata"?: number;
        /**
          * Fired when the terrain layer is ready.
          * @event ready
         */
        "onReady"?: (event: VMapLayerTerrainGeotiffCustomEvent<void>) => void;
        /**
          * Opacity of the terrain layer (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Quell-Projektion des GeoTIFF (z. B. "EPSG:32632" oder proj4-String)
          * @default null
         */
        "projection"?: string;
        /**
          * Rendering mode for GeoTIFF terrain.
          * @default terrain
         */
        "renderMode"?: 'terrain' | 'colormap';
        /**
          * Optional texture URL (can be an image or tile URL).
          * @default null
         */
        "texture"?: string;
        /**
          * Tile size in pixels.
          * @default 256
         */
        "tileSize"?: number;
        /**
          * URL to the GeoTIFF file containing elevation data.
          * @default null
         */
        "url"?: string;
        /**
          * Value range for colormap normalization [min, max].
          * @default null
         */
        "valueRange"?: [number, number];
        /**
          * Sichtbarkeit des Layers
          * @default true
         */
        "visible"?: boolean;
        /**
          * Enable wireframe mode (show only mesh lines).
          * @default false
         */
        "wireframe"?: boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 100
         */
        "zIndex"?: number;
    }
    interface VMapLayerTile3d {
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Fired once the tileset layer is initialised.
         */
        "onReady"?: (event: VMapLayerTile3dCustomEvent<void>) => void;
        /**
          * Global opacity factor (0-1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Optional JSON string or object with Cesium3DTileset options.
         */
        "tilesetOptions"?: string | Record<string, unknown>;
        /**
          * URL pointing to the Cesium 3D Tileset.
         */
        "url": string;
        /**
          * Whether the tileset should be visible.
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-index used for ordering tilesets.
          * @default 1000
         */
        "zIndex"?: number;
    }
    interface VMapLayerWcs {
        /**
          * Coverage-Name/ID.
         */
        "coverageName": string;
        /**
          * Ausgabeformat, z. B. image/tiff.
          * @default 'image/tiff'
         */
        "format"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Zusätzliche Parameter als JSON-String.
         */
        "params"?: string;
        /**
          * Projektion (Projection) für die Quelle.
         */
        "projection"?: string;
        /**
          * Auflösungen als JSON-Array, z. B. [1000,500].
         */
        "resolutions"?: string;
        /**
          * Basis-URL des WCS-Dienstes.
         */
        "url": string;
        /**
          * WCS-Version.
          * @default '1.1.0'
         */
        "version"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-Index für die Darstellung.
          * @default 1000
         */
        "zIndex"?: number;
    }
    interface VMapLayerWfs {
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Opazität (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Ausgabeformat, z. B. application/json.
          * @default 'application/json'
         */
        "outputFormat"?: string;
        /**
          * Zusätzliche Parameter als JSON-String.
         */
        "params"?: string;
        /**
          * Ziel-Referenzsystem, Standard EPSG:3857.
          * @default 'EPSG:3857'
         */
        "srsName"?: string;
        /**
          * Feature-Typ (typeName) des WFS.
         */
        "typeName": string;
        /**
          * WFS Endpunkt (z. B. https://server/wfs).
         */
        "url": string;
        /**
          * WFS Version, Standard 1.1.0.
          * @default '1.1.0'
         */
        "version"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-Index für Rendering.
          * @default 1000
         */
        "zIndex"?: number;
    }
    interface VMapLayerWkt {
        /**
          * Fill color for polygon geometries (CSS color value)
          * @default 'rgba(0,100,255,0.3)'
         */
        "fillColor"?: string;
        /**
          * Fill opacity for polygon geometries (0-1)
          * @default 0.3
         */
        "fillOpacity"?: number;
        /**
          * Icon size as [width, height] in pixels (comma-separated string like "32,32")
          * @default "32,32"
         */
        "iconSize"?: string;
        /**
          * Icon URL for point features (alternative to pointColor/pointRadius)
         */
        "iconUrl"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Signalisiert, dass das WKT-Layer initialisiert ist.
          * @event ready
         */
        "onReady"?: (event: VMapLayerWktCustomEvent<void>) => void;
        /**
          * Globale Opazität (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Point color for point geometries (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "pointColor"?: string;
        /**
          * Point radius for point geometries in pixels
          * @default 6
         */
        "pointRadius"?: number;
        /**
          * Stroke color for lines and polygon outlines (CSS color value)
          * @default 'rgba(0,100,255,1)'
         */
        "strokeColor"?: string;
        /**
          * Stroke opacity (0-1)
          * @default 1
         */
        "strokeOpacity"?: number;
        /**
          * Stroke width in pixels
          * @default 2
         */
        "strokeWidth"?: number;
        /**
          * Text color for labels (CSS color value)
          * @default '#000000'
         */
        "textColor"?: string;
        /**
          * Text property name from feature properties to display as label
         */
        "textProperty"?: string;
        /**
          * Text size for labels in pixels
          * @default 12
         */
        "textSize"?: number;
        /**
          * URL, von der eine WKT-Geometrie geladen wird (alternativ zu `wkt`).
         */
        "url"?: string;
        /**
          * Sichtbarkeit des Layers.
          * @default true
         */
        "visible"?: boolean;
        /**
          * WKT-Geometrie (z. B. "POINT(11.57 48.14)" oder "POLYGON((...))").
         */
        "wkt"?: string;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 1000
         */
        "zIndex"?: number;
    }
    /**
     * OGC WMS Layer
     */
    interface VMapLayerWms {
        /**
          * Bildformat des GetMap-Requests.
          * @default "image/png"
         */
        "format"?: string;
        /**
          * Kommagetrennte Layer-Namen (z. B. "topp:states").
         */
        "layers": string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Signalisiert, dass der WMS-Layer bereit ist.
          * @event ready
         */
        "onReady"?: (event: VMapLayerWmsCustomEvent<void>) => void;
        /**
          * Globale Opazität des WMS-Layers (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * WMS-`STYLES` Parameter (kommagetrennt).
          * @default ""
         */
        "styles"?: string;
        /**
          * Tiled/geslicete Requests verwenden (falls Server unterstützt).
          * @default true
         */
        "tiled"?: boolean;
        /**
          * Transparente Kacheln anfordern.
          * @default true
         */
        "transparent"?: boolean;
        /**
          * Basis-URL des WMS-Dienstes (GetMap-Endpunkt ohne Query-Parameter).
         */
        "url": string;
        /**
          * Sichtbarkeit des WMS-Layers.
          * @default true
         */
        "visible"?: boolean;
        /**
          * Z-index for layer stacking order. Higher values render on top.
          * @default 10
         */
        "zIndex"?: number;
    }
    /**
     * XYZ Tile Layer
     */
    interface VMapLayerXyz {
        /**
          * Attributions-/Copyright-Text (HTML erlaubt).
         */
        "attributions"?: string;
        /**
          * Current load state of the layer.
          * @default 'idle'
         */
        "loadState"?: 'idle' | 'loading' | 'ready' | 'error';
        /**
          * Maximaler Zoomlevel, den der Tile-Server liefert.
          * @default 19
         */
        "maxZoom"?: number;
        /**
          * Wird ausgelöst, wenn der XYZ-Layer bereit ist.
          * @event ready
         */
        "onReady"?: (event: VMapLayerXyzCustomEvent<void>) => void;
        /**
          * Opazität (0–1).
          * @default 1
         */
        "opacity"?: number;
        /**
          * Subdomains für parallele Tile-Anfragen (z. B. "a,b,c").
         */
        "subdomains"?: string;
        /**
          * Größe einer Kachel in Pixeln.
          * @default 256
         */
        "tileSize"?: number;
        /**
          * URL-Template für Kacheln, z. B. "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png".
         */
        "url": string;
        /**
          * Sichtbarkeit des XYZ-Layers.
          * @default true
         */
        "visible"?: boolean;
    }
    interface VMapLayercontrol {
        /**
          * ID der zu steuernden Karte (DOM-Element mit dieser id)
         */
        "for"?: string;
    }
    interface VMapLayergroup {
        /**
          * Base map identifier for this layer group. When set, layers in this group will be treated as base map layers.
          * @default null
         */
        "basemapid"?: string | null;
        /**
          * Globale Opazität (0–1) für alle Kinder.
          * @default 1
         */
        "opacity"?: number;
        /**
          * Sichtbarkeit der gesamten Gruppe.
          * @default true
         */
        "visible"?: boolean;
    }
    interface VMapStyle {
        /**
          * Whether to automatically apply the style when loaded.
          * @default true
         */
        "autoApply"?: boolean;
        /**
          * Inline style content as string (alternative to src).
         */
        "content"?: string;
        /**
          * The styling format to parse (supports 'sld', 'mapbox-gl', 'qgis', 'lyrx', 'cesium-3d-tiles').
          * @default 'sld'
         */
        "format"?: StyleFormat;
        /**
          * Target layer IDs to apply this style to. If not specified, applies to all compatible layers.
         */
        "layerTargets"?: string;
        /**
          * Fired when style parsing fails.
         */
        "onStyleError"?: (event: VMapStyleCustomEvent<Error>) => void;
        /**
          * Fired when style is successfully parsed and ready to apply.
         */
        "onStyleReady"?: (event: VMapStyleCustomEvent<StyleEvent>) => void;
        /**
          * The style source - can be a URL to fetch from or inline SLD/style content.
         */
        "src"?: string;
    }

    interface VMapAttributes {
        "flavour": Flavour;
        "center": string;
        "zoom": number;
        "useDefaultImportMap": boolean;
        "cssMode": CssMode;
    }
    interface VMapErrorAttributes {
        "for": string;
        "position": ToastPosition;
        "autoDismiss": number;
        "max": number;
        "log": LogMode;
    }
    interface VMapLayerGeojsonAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "geojson": string;
        "url": string | null;
        "visible": boolean;
        "zIndex": number;
        "opacity": number;
        "fillColor": string;
        "fillOpacity": number;
        "strokeColor": string;
        "strokeWidth": number;
        "strokeOpacity": number;
        "pointRadius": number;
        "pointColor": string;
        "iconUrl": string;
        "iconSize": string;
        "textProperty": string;
        "textColor": string;
        "textSize": number;
    }
    interface VMapLayerGeotiffAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
        "nodata": number;
        "colorMap": string | GeoStylerColorMap;
    }
    interface VMapLayerGoogleAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "mapType": | 'roadmap'
    | 'satellite'
    | 'terrain'
    | 'hybrid';
        "apiKey": string;
        "language": string;
        "region": string;
        "visible": boolean;
        "opacity": number;
        "scale": 'scaleFactor1x' | 'scaleFactor2x' | 'scaleFactor4x';
        "maxZoom": number;
        "styles": Record<string, unknown>[] | string;
        "libraries": string;
    }
    interface VMapLayerOsmAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
        "url": string;
    }
    interface VMapLayerScatterplotAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "data": string;
        "url": string;
        "getFillColor": Color;
        "getRadius": number;
        "opacity": number;
        "visible": boolean;
    }
    interface VMapLayerTerrainAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "elevationData": string;
        "texture": string;
        "elevationDecoder": string;
        "wireframe": boolean;
        "color": string;
        "minZoom": number;
        "maxZoom": number;
        "meshMaxError": number;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
    }
    interface VMapLayerTerrainGeotiffAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "projection": string;
        "forceProjection": boolean;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
        "nodata": number;
        "meshMaxError": number;
        "wireframe": boolean;
        "texture": string;
        "colorMap": string | GeoStylerColorMap;
        "elevationScale": number;
        "renderMode": 'terrain' | 'colormap';
        "minZoom": number;
        "maxZoom": number;
        "tileSize": number;
    }
    interface VMapLayerTile3dAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "tilesetOptions": string | Record<string, unknown>;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
    }
    interface VMapLayerWcsAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "coverageName": string;
        "format": string;
        "version": string;
        "projection": string;
        "resolutions": string;
        "params": string;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
    }
    interface VMapLayerWfsAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "typeName": string;
        "version": string;
        "outputFormat": string;
        "srsName": string;
        "params": string;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
    }
    interface VMapLayerWktAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "wkt": string;
        "url": string;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
        "fillColor": string;
        "fillOpacity": number;
        "strokeColor": string;
        "strokeWidth": number;
        "strokeOpacity": number;
        "pointRadius": number;
        "pointColor": string;
        "iconUrl": string;
        "iconSize": string;
        "textProperty": string;
        "textColor": string;
        "textSize": number;
    }
    interface VMapLayerWmsAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "layers": string;
        "styles": string;
        "format": string;
        "transparent": boolean;
        "tiled": boolean;
        "visible": boolean;
        "opacity": number;
        "zIndex": number;
    }
    interface VMapLayerXyzAttributes {
        "loadState": 'idle' | 'loading' | 'ready' | 'error';
        "url": string;
        "attributions": string;
        "maxZoom": number;
        "tileSize": number;
        "subdomains": string;
        "visible": boolean;
        "opacity": number;
    }
    interface VMapLayercontrolAttributes {
        "for": string;
    }
    interface VMapLayergroupAttributes {
        "visible": boolean;
        "opacity": number;
        "basemapid": string | null;
    }
    interface VMapStyleAttributes {
        "format": StyleFormat;
        "src": string;
        "content": string;
        "layerTargets": string;
        "autoApply": boolean;
    }

    interface IntrinsicElements {
        "v-map": Omit<VMap, keyof VMapAttributes> & { [K in keyof VMap & keyof VMapAttributes]?: VMap[K] } & { [K in keyof VMap & keyof VMapAttributes as `attr:${K}`]?: VMapAttributes[K] } & { [K in keyof VMap & keyof VMapAttributes as `prop:${K}`]?: VMap[K] };
        "v-map-builder": VMapBuilder;
        "v-map-error": Omit<VMapError, keyof VMapErrorAttributes> & { [K in keyof VMapError & keyof VMapErrorAttributes]?: VMapError[K] } & { [K in keyof VMapError & keyof VMapErrorAttributes as `attr:${K}`]?: VMapErrorAttributes[K] } & { [K in keyof VMapError & keyof VMapErrorAttributes as `prop:${K}`]?: VMapError[K] };
        "v-map-layer-geojson": Omit<VMapLayerGeojson, keyof VMapLayerGeojsonAttributes> & { [K in keyof VMapLayerGeojson & keyof VMapLayerGeojsonAttributes]?: VMapLayerGeojson[K] } & { [K in keyof VMapLayerGeojson & keyof VMapLayerGeojsonAttributes as `attr:${K}`]?: VMapLayerGeojsonAttributes[K] } & { [K in keyof VMapLayerGeojson & keyof VMapLayerGeojsonAttributes as `prop:${K}`]?: VMapLayerGeojson[K] };
        "v-map-layer-geotiff": Omit<VMapLayerGeotiff, keyof VMapLayerGeotiffAttributes> & { [K in keyof VMapLayerGeotiff & keyof VMapLayerGeotiffAttributes]?: VMapLayerGeotiff[K] } & { [K in keyof VMapLayerGeotiff & keyof VMapLayerGeotiffAttributes as `attr:${K}`]?: VMapLayerGeotiffAttributes[K] } & { [K in keyof VMapLayerGeotiff & keyof VMapLayerGeotiffAttributes as `prop:${K}`]?: VMapLayerGeotiff[K] };
        "v-map-layer-google": Omit<VMapLayerGoogle, keyof VMapLayerGoogleAttributes> & { [K in keyof VMapLayerGoogle & keyof VMapLayerGoogleAttributes]?: VMapLayerGoogle[K] } & { [K in keyof VMapLayerGoogle & keyof VMapLayerGoogleAttributes as `attr:${K}`]?: VMapLayerGoogleAttributes[K] } & { [K in keyof VMapLayerGoogle & keyof VMapLayerGoogleAttributes as `prop:${K}`]?: VMapLayerGoogle[K] };
        "v-map-layer-osm": Omit<VMapLayerOsm, keyof VMapLayerOsmAttributes> & { [K in keyof VMapLayerOsm & keyof VMapLayerOsmAttributes]?: VMapLayerOsm[K] } & { [K in keyof VMapLayerOsm & keyof VMapLayerOsmAttributes as `attr:${K}`]?: VMapLayerOsmAttributes[K] } & { [K in keyof VMapLayerOsm & keyof VMapLayerOsmAttributes as `prop:${K}`]?: VMapLayerOsm[K] };
        "v-map-layer-scatterplot": Omit<VMapLayerScatterplot, keyof VMapLayerScatterplotAttributes> & { [K in keyof VMapLayerScatterplot & keyof VMapLayerScatterplotAttributes]?: VMapLayerScatterplot[K] } & { [K in keyof VMapLayerScatterplot & keyof VMapLayerScatterplotAttributes as `attr:${K}`]?: VMapLayerScatterplotAttributes[K] } & { [K in keyof VMapLayerScatterplot & keyof VMapLayerScatterplotAttributes as `prop:${K}`]?: VMapLayerScatterplot[K] };
        "v-map-layer-terrain": Omit<VMapLayerTerrain, keyof VMapLayerTerrainAttributes> & { [K in keyof VMapLayerTerrain & keyof VMapLayerTerrainAttributes]?: VMapLayerTerrain[K] } & { [K in keyof VMapLayerTerrain & keyof VMapLayerTerrainAttributes as `attr:${K}`]?: VMapLayerTerrainAttributes[K] } & { [K in keyof VMapLayerTerrain & keyof VMapLayerTerrainAttributes as `prop:${K}`]?: VMapLayerTerrain[K] } & OneOf<"elevationData", VMapLayerTerrain["elevationData"], VMapLayerTerrainAttributes["elevationData"]>;
        "v-map-layer-terrain-geotiff": Omit<VMapLayerTerrainGeotiff, keyof VMapLayerTerrainGeotiffAttributes> & { [K in keyof VMapLayerTerrainGeotiff & keyof VMapLayerTerrainGeotiffAttributes]?: VMapLayerTerrainGeotiff[K] } & { [K in keyof VMapLayerTerrainGeotiff & keyof VMapLayerTerrainGeotiffAttributes as `attr:${K}`]?: VMapLayerTerrainGeotiffAttributes[K] } & { [K in keyof VMapLayerTerrainGeotiff & keyof VMapLayerTerrainGeotiffAttributes as `prop:${K}`]?: VMapLayerTerrainGeotiff[K] };
        "v-map-layer-tile3d": Omit<VMapLayerTile3d, keyof VMapLayerTile3dAttributes> & { [K in keyof VMapLayerTile3d & keyof VMapLayerTile3dAttributes]?: VMapLayerTile3d[K] } & { [K in keyof VMapLayerTile3d & keyof VMapLayerTile3dAttributes as `attr:${K}`]?: VMapLayerTile3dAttributes[K] } & { [K in keyof VMapLayerTile3d & keyof VMapLayerTile3dAttributes as `prop:${K}`]?: VMapLayerTile3d[K] } & OneOf<"url", VMapLayerTile3d["url"], VMapLayerTile3dAttributes["url"]>;
        "v-map-layer-wcs": Omit<VMapLayerWcs, keyof VMapLayerWcsAttributes> & { [K in keyof VMapLayerWcs & keyof VMapLayerWcsAttributes]?: VMapLayerWcs[K] } & { [K in keyof VMapLayerWcs & keyof VMapLayerWcsAttributes as `attr:${K}`]?: VMapLayerWcsAttributes[K] } & { [K in keyof VMapLayerWcs & keyof VMapLayerWcsAttributes as `prop:${K}`]?: VMapLayerWcs[K] } & OneOf<"url", VMapLayerWcs["url"], VMapLayerWcsAttributes["url"]> & OneOf<"coverageName", VMapLayerWcs["coverageName"], VMapLayerWcsAttributes["coverageName"]>;
        "v-map-layer-wfs": Omit<VMapLayerWfs, keyof VMapLayerWfsAttributes> & { [K in keyof VMapLayerWfs & keyof VMapLayerWfsAttributes]?: VMapLayerWfs[K] } & { [K in keyof VMapLayerWfs & keyof VMapLayerWfsAttributes as `attr:${K}`]?: VMapLayerWfsAttributes[K] } & { [K in keyof VMapLayerWfs & keyof VMapLayerWfsAttributes as `prop:${K}`]?: VMapLayerWfs[K] } & OneOf<"url", VMapLayerWfs["url"], VMapLayerWfsAttributes["url"]> & OneOf<"typeName", VMapLayerWfs["typeName"], VMapLayerWfsAttributes["typeName"]>;
        "v-map-layer-wkt": Omit<VMapLayerWkt, keyof VMapLayerWktAttributes> & { [K in keyof VMapLayerWkt & keyof VMapLayerWktAttributes]?: VMapLayerWkt[K] } & { [K in keyof VMapLayerWkt & keyof VMapLayerWktAttributes as `attr:${K}`]?: VMapLayerWktAttributes[K] } & { [K in keyof VMapLayerWkt & keyof VMapLayerWktAttributes as `prop:${K}`]?: VMapLayerWkt[K] };
        "v-map-layer-wms": Omit<VMapLayerWms, keyof VMapLayerWmsAttributes> & { [K in keyof VMapLayerWms & keyof VMapLayerWmsAttributes]?: VMapLayerWms[K] } & { [K in keyof VMapLayerWms & keyof VMapLayerWmsAttributes as `attr:${K}`]?: VMapLayerWmsAttributes[K] } & { [K in keyof VMapLayerWms & keyof VMapLayerWmsAttributes as `prop:${K}`]?: VMapLayerWms[K] } & OneOf<"url", VMapLayerWms["url"], VMapLayerWmsAttributes["url"]> & OneOf<"layers", VMapLayerWms["layers"], VMapLayerWmsAttributes["layers"]>;
        "v-map-layer-xyz": Omit<VMapLayerXyz, keyof VMapLayerXyzAttributes> & { [K in keyof VMapLayerXyz & keyof VMapLayerXyzAttributes]?: VMapLayerXyz[K] } & { [K in keyof VMapLayerXyz & keyof VMapLayerXyzAttributes as `attr:${K}`]?: VMapLayerXyzAttributes[K] } & { [K in keyof VMapLayerXyz & keyof VMapLayerXyzAttributes as `prop:${K}`]?: VMapLayerXyz[K] } & OneOf<"url", VMapLayerXyz["url"], VMapLayerXyzAttributes["url"]>;
        "v-map-layercontrol": Omit<VMapLayercontrol, keyof VMapLayercontrolAttributes> & { [K in keyof VMapLayercontrol & keyof VMapLayercontrolAttributes]?: VMapLayercontrol[K] } & { [K in keyof VMapLayercontrol & keyof VMapLayercontrolAttributes as `attr:${K}`]?: VMapLayercontrolAttributes[K] } & { [K in keyof VMapLayercontrol & keyof VMapLayercontrolAttributes as `prop:${K}`]?: VMapLayercontrol[K] };
        "v-map-layergroup": Omit<VMapLayergroup, keyof VMapLayergroupAttributes> & { [K in keyof VMapLayergroup & keyof VMapLayergroupAttributes]?: VMapLayergroup[K] } & { [K in keyof VMapLayergroup & keyof VMapLayergroupAttributes as `attr:${K}`]?: VMapLayergroupAttributes[K] } & { [K in keyof VMapLayergroup & keyof VMapLayergroupAttributes as `prop:${K}`]?: VMapLayergroup[K] };
        "v-map-style": Omit<VMapStyle, keyof VMapStyleAttributes> & { [K in keyof VMapStyle & keyof VMapStyleAttributes]?: VMapStyle[K] } & { [K in keyof VMapStyle & keyof VMapStyleAttributes as `attr:${K}`]?: VMapStyleAttributes[K] } & { [K in keyof VMapStyle & keyof VMapStyleAttributes as `prop:${K}`]?: VMapStyle[K] };
    }
}
export { LocalJSX as JSX };
declare module "@stencil/core" {
    export namespace JSX {
        interface IntrinsicElements {
            "v-map": LocalJSX.IntrinsicElements["v-map"] & JSXBase.HTMLAttributes<HTMLVMapElement>;
            /**
             * A component that builds map configurations dynamically from JSON/YAML configuration scripts.
             */
            "v-map-builder": LocalJSX.IntrinsicElements["v-map-builder"] & JSXBase.HTMLAttributes<HTMLVMapBuilderElement>;
            /**
             * `<v-map-error>` lauscht auf das `vmap-error` Event seiner Eltern-`<v-map>`
             * (oder einer per `for`-Attribut adressierten Karte) und rendert die Fehler
             * als kleine, opinionated gestylte Toast-Stapel innerhalb des Karten-Containers.
             * Damit können einfache HTML-Beispiele Fehler sichtbar machen, ohne eine
             * Zeile JavaScript zu schreiben.
             * @example ```html
             * <v-map flavour="ol">
             *   <v-map-error position="top-right" auto-dismiss="5000"></v-map-error>
             *   <v-map-layergroup group-title="Basiskarten" basemapid="OSM-BASE">
             *     <v-map-layer-osm id="OSM-BASE" label="OSM"></v-map-layer-osm>
             *   </v-map-layergroup>
             * </v-map>
             * ```
             */
            "v-map-error": LocalJSX.IntrinsicElements["v-map-error"] & JSXBase.HTMLAttributes<HTMLVMapErrorElement>;
            "v-map-layer-geojson": LocalJSX.IntrinsicElements["v-map-layer-geojson"] & JSXBase.HTMLAttributes<HTMLVMapLayerGeojsonElement>;
            "v-map-layer-geotiff": LocalJSX.IntrinsicElements["v-map-layer-geotiff"] & JSXBase.HTMLAttributes<HTMLVMapLayerGeotiffElement>;
            /**
             * Google Maps Basemap Layer
             */
            "v-map-layer-google": LocalJSX.IntrinsicElements["v-map-layer-google"] & JSXBase.HTMLAttributes<HTMLVMapLayerGoogleElement>;
            "v-map-layer-osm": LocalJSX.IntrinsicElements["v-map-layer-osm"] & JSXBase.HTMLAttributes<HTMLVMapLayerOsmElement>;
            "v-map-layer-scatterplot": LocalJSX.IntrinsicElements["v-map-layer-scatterplot"] & JSXBase.HTMLAttributes<HTMLVMapLayerScatterplotElement>;
            "v-map-layer-terrain": LocalJSX.IntrinsicElements["v-map-layer-terrain"] & JSXBase.HTMLAttributes<HTMLVMapLayerTerrainElement>;
            "v-map-layer-terrain-geotiff": LocalJSX.IntrinsicElements["v-map-layer-terrain-geotiff"] & JSXBase.HTMLAttributes<HTMLVMapLayerTerrainGeotiffElement>;
            "v-map-layer-tile3d": LocalJSX.IntrinsicElements["v-map-layer-tile3d"] & JSXBase.HTMLAttributes<HTMLVMapLayerTile3dElement>;
            "v-map-layer-wcs": LocalJSX.IntrinsicElements["v-map-layer-wcs"] & JSXBase.HTMLAttributes<HTMLVMapLayerWcsElement>;
            "v-map-layer-wfs": LocalJSX.IntrinsicElements["v-map-layer-wfs"] & JSXBase.HTMLAttributes<HTMLVMapLayerWfsElement>;
            "v-map-layer-wkt": LocalJSX.IntrinsicElements["v-map-layer-wkt"] & JSXBase.HTMLAttributes<HTMLVMapLayerWktElement>;
            /**
             * OGC WMS Layer
             */
            "v-map-layer-wms": LocalJSX.IntrinsicElements["v-map-layer-wms"] & JSXBase.HTMLAttributes<HTMLVMapLayerWmsElement>;
            /**
             * XYZ Tile Layer
             */
            "v-map-layer-xyz": LocalJSX.IntrinsicElements["v-map-layer-xyz"] & JSXBase.HTMLAttributes<HTMLVMapLayerXyzElement>;
            "v-map-layercontrol": LocalJSX.IntrinsicElements["v-map-layercontrol"] & JSXBase.HTMLAttributes<HTMLVMapLayercontrolElement>;
            "v-map-layergroup": LocalJSX.IntrinsicElements["v-map-layergroup"] & JSXBase.HTMLAttributes<HTMLVMapLayergroupElement>;
            "v-map-style": LocalJSX.IntrinsicElements["v-map-style"] & JSXBase.HTMLAttributes<HTMLVMapStyleElement>;
        }
    }
}