@npm9912/v-map 0.1.0

package/dist/types/globals.d.ts

@@ -0,0 +1,16 @@
+import type { CesiumNS, OlNS } from './namespaces';
+
+// Fix for OpenLayers PaletteTexture TypeScript compatibility issue
+declare module "ol/webgl/PaletteTexture" {
+  export interface PaletteTexture {
+    name: string;
+    data: Uint8Array; // Fixed: removed generic <ArrayBufferLike>
+  }
+}
+
+declare global {
+  // weil du per <script> lädst:
+  var Cesium: CesiumNS | undefined; // globalThis.Cesium
+  var ol: OlNS | undefined; // globalThis.ol (falls genutzt)
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview entry point for your component library
+ *
+ * This is the entry point for your component library. Use this file to export utilities,
+ * constants or data structure that accompany your components.
+ *
+ * DO NOT use this file to export your components. Instead, use the recommended approaches
+ * to consume components of this package as outlined in the `README.md`.
+ */
+export type * from './components.d.ts';

package/dist/types/layer/v-map-layer-helper.d.ts

@@ -0,0 +1,45 @@
+import type { LayerConfig } from '../types/layerconfig';
+import { type VMapErrorDetail } from '../utils/events';
+import type { MapProvider, LayerUpdate } from '../types/mapprovider';
+export interface VMapErrorHost {
+    /** Called by the helper to set the component load state */
+    setLoadState(state: 'idle' | 'loading' | 'ready' | 'error'): void;
+}
+export declare class VMapLayerHelper {
+    private el;
+    private static readonly RUNTIME_ERROR_DEBOUNCE_MS;
+    private layerId;
+    private mapProvider;
+    private _error?;
+    private host?;
+    private initContext?;
+    private listenersBound;
+    private recreateInFlight;
+    private lastRuntimeErrorTime;
+    constructor(el: HTMLElement, host?: VMapErrorHost);
+    startLoading(): void;
+    markReady(): void;
+    markUpdated(): void;
+    setError(detail: VMapErrorDetail): void;
+    setRuntimeError(detail: VMapErrorDetail): void;
+    clearError(): void;
+    getError(): VMapErrorDetail | undefined;
+    private addLayer;
+    protected addToMapInternal(group: HTMLVMapLayergroupElement, vmap: HTMLVMapElement, createLayerConfig: () => LayerConfig, elementId?: string): Promise<void>;
+    private bindMapEventsOnce;
+    private readonly onMapProviderReady;
+    private readonly onMapProviderWillShutdown;
+    setVisible(visible: boolean): Promise<void>;
+    setOpacity(opacity: number): Promise<void>;
+    setZIndex(zIndex: number): Promise<void>;
+    updateLayer(update: LayerUpdate): Promise<void>;
+    recreateLayer(): Promise<void>;
+    initLayer(createLayerConfig: () => LayerConfig, elementId?: string): Promise<void>;
+    dispose(): Promise<void>;
+    getMapProvider(): MapProvider;
+    getLayerId(): string;
+    removeLayer(): Promise<void>;
+    private registerLayerError;
+    private unregisterLayerError;
+    private getVMap;
+}

package/dist/types/layer/v-map-layer-helper.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/leaflet-augment.d.ts

@@ -0,0 +1,15 @@
+import 'leaflet';
+
+declare module 'leaflet' {
+  interface Layer {
+    vmapVisible?: boolean;
+    vmapOpacity?: number;
+    layerElementId?: string;
+  }
+
+  interface LayerGroup<P = any> {
+    _groupId?: string;
+    visible?: boolean;
+    basemap?: boolean;
+  }
+}

package/dist/types/lib/cesium-loader.d.ts

@@ -0,0 +1,3 @@
+import type { CesiumNS } from '../../types/namespaces';
+export declare function loadCesium(version?: "1.139.1"): Promise<CesiumNS>;
+export declare function injectWidgetsCss(shadowRoot?: ShadowRoot): Promise<void>;

package/dist/types/lib/ensure-importmap.d.ts

@@ -0,0 +1,3 @@
+export declare function ensureImportMap({ allowOverride }?: {
+    allowOverride?: boolean;
+}): void;

package/dist/types/lib/ensure-importmap.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/versions.gen.d.ts

@@ -0,0 +1,5 @@
+export declare const CESIUM_VERSION: "1.139.1";
+export declare const OL_VERSION: "10.8.0";
+export declare const LEAFLET_VERSION: "1.9.4";
+export declare const DECK_VERSION: "9.2.11";
+export declare const IMPORT_MAP_JSON: "{\n  \"imports\": {\n    \"ol/\": \"https://esm.sh/ol@10.8.0/\",\n    \"ol\": \"https://esm.sh/ol@10.8.0\",\n    \"leaflet\": \"https://esm.sh/leaflet@1.9.4\",\n    \"deck\": \"https://esm.sh/deck@9.2.11\",\n    \"@loaders.gl/core\": \"https://esm.sh/@loaders.gl/core@4.3.4\",\n    \"@loaders.gl/3d-tiles\": \"https://esm.sh/@loaders.gl/3d-tiles@4.3.4\",\n    \"@loaders.gl/gis\": \"https://esm.sh/@loaders.gl/gis@4.3.4\",\n    \"@loaders.gl/gltf\": \"https://esm.sh/@loaders.gl/gltf@4.3.4\",\n    \"@loaders.gl/images\": \"https://esm.sh/@loaders.gl/images@4.3.4\",\n    \"@loaders.gl/loader-utils\": \"https://esm.sh/@loaders.gl/loader-utils@4.3.4\",\n    \"@loaders.gl/mvt\": \"https://esm.sh/@loaders.gl/mvt@4.3.4\",\n    \"@loaders.gl/schema\": \"https://esm.sh/@loaders.gl/schema@4.3.4\",\n    \"@loaders.gl/terrain\": \"https://esm.sh/@loaders.gl/terrain@4.3.4\",\n    \"@loaders.gl/textures\": \"https://esm.sh/@loaders.gl/textures@4.3.4\",\n    \"@loaders.gl/tiles\": \"https://esm.sh/@loaders.gl/tiles@4.3.4\",\n    \"@loaders.gl/wms\": \"https://esm.sh/@loaders.gl/wms@4.3.4\"\n  }\n}";

package/dist/types/lib/vstyle.d.ts

@@ -0,0 +1,44 @@
+export type Color = string | [number, number, number, number?];
+export type Expr<T = unknown> = T | unknown[];
+export type VStyleRule = {
+    when?: Expr<boolean>;
+    point?: {
+        radius?: Expr<number>;
+        fill?: Expr<Color>;
+        stroke?: {
+            color?: Expr<Color>;
+            width?: Expr<number>;
+        };
+        icon?: {
+            url: string;
+            size?: number;
+            anchor?: [number, number];
+        };
+    };
+    line?: {
+        color?: Expr<Color>;
+        width?: Expr<number>;
+        dasharray?: number[];
+    };
+    polygon?: {
+        fill?: Expr<Color>;
+        stroke?: {
+            color?: Expr<Color>;
+            width?: Expr<number>;
+        };
+    };
+    label?: {
+        text?: Expr<string>;
+        color?: Expr<Color>;
+        size?: Expr<number>;
+        halo?: {
+            color?: Expr<Color>;
+            width?: Expr<number>;
+        };
+    };
+};
+export type VStyle = {
+    rules: VStyleRule[];
+    vars?: Record<string, Color | number | string>;
+};
+export declare const VSTYLE_DEFAULT: VStyle;

package/dist/types/map-provider/cesium/CesiumGeoTIFFTerrainProvider.d.ts

@@ -0,0 +1,92 @@
+type CesiumModule = typeof import('cesium');
+import type { TerrainProvider, TilingScheme, TerrainData, Rectangle, Credit, TileAvailability, Event as CesiumEvent } from 'cesium';
+export interface CesiumGeoTIFFTerrainProviderOptions {
+    url: string;
+    projection?: string;
+    forceProjection?: boolean;
+    nodata?: number;
+    Cesium: CesiumModule;
+}
+/**
+ * Custom Cesium Terrain Provider for GeoTIFF elevation data
+ *
+ * This provider loads a GeoTIFF file containing elevation data and provides
+ * it to Cesium's terrain system as a heightmap.
+ */
+export declare class CesiumGeoTIFFTerrainProvider implements TerrainProvider {
+    private Cesium;
+    private image?;
+    private fromProjection;
+    private sourceBounds;
+    private wgs84Bounds;
+    private width;
+    private height;
+    private noDataValue;
+    private ready;
+    private _readyPromise;
+    private heightmapWidth;
+    private heightmapHeight;
+    private proj4;
+    tilingScheme: TilingScheme;
+    constructor(options: CesiumGeoTIFFTerrainProviderOptions);
+    private initialize;
+    /**
+     * Get the coverage rectangle in WGS84 coordinates
+     */
+    get rectangle(): Rectangle;
+    /**
+     * Request tile geometry for a specific tile
+     */
+    requestTileGeometry(x: number, y: number, level: number): Promise<TerrainData>;
+    /**
+     * Create a flat heightmap for tiles outside the GeoTIFF bounds
+     */
+    private createFlatHeightmap;
+    /**
+     * Get the availability of tiles
+     */
+    get availability(): TileAvailability | undefined;
+    /**
+     * Get the tiling scheme
+     */
+    getTilingScheme(): TilingScheme;
+    /**
+     * Get the maximum geometric error allowed at a specific level
+     * Required by Cesium's TerrainProvider interface
+     *
+     * The geometric error is the difference (in meters) between the actual terrain
+     * and the terrain approximation at this level. Higher levels have lower error.
+     */
+    getLevelMaximumGeometricError(level: number): number;
+    loadTileDataAvailability(_x: number, _y: number, _level: number): undefined | Promise<void>;
+    /**
+     * Check if tile data is available for a specific tile
+     * Required by Cesium's TerrainProvider interface
+     */
+    getTileDataAvailable(x: number, y: number, level: number): boolean | undefined;
+    /**
+     * Check if the provider is ready
+     */
+    get readyPromise(): Promise<boolean>;
+    /**
+     * Get the credit to display
+     */
+    get credit(): Credit;
+    /**
+     * Check if the provider has water mask
+     */
+    get hasWaterMask(): boolean;
+    /**
+     * Check if the provider has vertex normals
+     */
+    get hasVertexNormals(): boolean;
+    /**
+     * Get the error event
+     */
+    get errorEvent(): CesiumEvent<TerrainProvider.ErrorEvent>;
+}
+/**
+ * Factory function to create a CesiumGeoTIFFTerrainProvider
+ */
+export declare function createCesiumGeoTIFFTerrainProvider(options: CesiumGeoTIFFTerrainProviderOptions): Promise<TerrainProvider>;
+export {};

package/dist/types/map-provider/cesium/CesiumLayerGroups.d.ts

@@ -0,0 +1,64 @@
+import type { Color } from 'cesium';
+import { ILayer } from './i-layer';
+export interface I3DTilesLayer extends ILayer {
+    setColor(color: string | Color, opacity?: number): void;
+    setStyle(style: Record<string, unknown>): void;
+}
+export type AnyLayer = ILayer | I3DTilesLayer;
+interface CesiumLayerRef {
+    /** interne Layer-ID (dein layerId) */
+    id: string;
+    /** optionale Basemap-Key (z. B. "osm", "satellite") */
+    elementId?: string | null;
+    /** Wrapper aus LayerManager */
+    layer: AnyLayer;
+}
+/**
+ * Eine Gruppe verwaltet Sichtbarkeit & Basemap-Filter ihrer Cesium-Layer.
+ * - group.visible = false  => Alle Layer der Gruppe unsichtbar.
+ * - group.basemap = "X"    => Nur Layer mit elementId==="X" in der Gruppe sichtbar.
+ * - Der ursprüngliche Sichtbarkeitszustand jedes Layers wird gemerkt und bei
+ *   Re-Aktivierung wiederhergestellt.
+ */
+export declare class CesiumLayerGroup {
+    readonly id: string;
+    private _visible;
+    private _basemap;
+    private _layers;
+    private _originalVisible;
+    private _dirty;
+    constructor(id: string, visible?: boolean);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get basemap(): string | null;
+    set basemap(b: string | null);
+    isDirty(): boolean;
+    addLayer(ref: CesiumLayerRef): void;
+    /** optional zum Nachziehen von elementId (z. B. wenn erst später bekannt) */
+    setLayerElementId(layerId: string, elementId?: string | null): void;
+    removeLayer(layerId: string): boolean;
+    clear(): void;
+    /** zentrale Logik: Basemap/Visibility anwenden */
+    apply(): void;
+}
+/**
+ * Root-Store für mehrere Cesium-Gruppen.
+ * - Ordnung/Z-Index übernimmst du weiterhin im LayerManager pro Layer.
+ * - Diese Klasse kümmert sich um Gruppensichtbarkeit & Basemap-Filter.
+ */
+export declare class CesiumLayerGroups {
+    private _groups;
+    private _dirty;
+    get groups(): readonly CesiumLayerGroup[];
+    getGroup(id: string): CesiumLayerGroup | undefined;
+    hasGroup(id: string): boolean;
+    ensureGroup(id: string, visible?: boolean): CesiumLayerGroup;
+    addLayerToGroup(groupId: string, visible: boolean, ref: CesiumLayerRef): void;
+    removeLayer(layerId: string, removeFromAll?: boolean): boolean;
+    setGroupVisible(groupId: string, visible: boolean): void;
+    setBasemap(groupId: string, basemap: string | null): void;
+    /** Wendet alle Gruppenregeln an (sichtbar/basemap). */
+    apply(): void;
+    clear(): void;
+}
+export {};

package/dist/types/map-provider/cesium/GeoTIFFImageryProvider.d.ts

@@ -0,0 +1,75 @@
+import type { ColorStop } from '../geotiff/utils/colormap-utils';
+import { GeoTIFFTileProcessor } from '../geotiff/utils/GeoTIFFTileProcessor';
+type CesiumModule = typeof import('cesium');
+import type { Credit, Event as CesiumEvent, ImageryProvider, Rectangle, TileDiscardPolicy, TilingScheme } from 'cesium';
+export interface CesiumGeoTIFFImageryOptions {
+    Cesium: CesiumModule;
+    rectangleDegrees: [number, number, number, number];
+    tileProcessor: GeoTIFFTileProcessor;
+    tileSize: number;
+    resolution: number;
+    resampleMethod: 'near' | 'bilinear';
+    colorStops?: ColorStop[];
+    minimumLevel?: number;
+    maximumLevel?: number;
+}
+/**
+ * Custom ImageryProvider that renders GeoTIFF tiles on demand using
+ * the shared GeoTIFFTileProcessor (triangulation-based reprojection).
+ */
+export declare class GeoTIFFImageryProvider implements ImageryProvider {
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly tilingScheme: TilingScheme;
+    readonly rectangle: Rectangle;
+    readonly errorEvent: CesiumEvent;
+    readonly credit: Credit | undefined;
+    readonly tileDiscardPolicy: TileDiscardPolicy | undefined;
+    readonly proxy: undefined;
+    readonly hasAlphaChannel = true;
+    readonly minimumLevel: number;
+    readonly maximumLevel: number | undefined;
+    private readonly Cesium;
+    private readonly tileProcessor;
+    private readonly resolution;
+    private readonly resampleMethod;
+    private readonly colorStops?;
+    private readonly readyPromiseInternal;
+    ready: boolean;
+    constructor(options: CesiumGeoTIFFImageryOptions);
+    get tilingSchemeName(): string | undefined;
+    get readyPromise(): Promise<boolean>;
+    get tileCredits(): import('cesium').Credit[] | undefined;
+    getTileCredits(_x: number, _y: number, _level: number): import('cesium').Credit[] | undefined;
+    get url(): string | undefined;
+    /**
+     * Flips a canvas vertically (Y-axis inversion) for Cesium.
+     * Creates a new canvas with the flipped content.
+     *
+     * @param sourceCanvas - The canvas to flip
+     * @param width - Width of the canvas
+     * @param height - Height of the canvas
+     * @returns A new canvas with vertically flipped content, or the source canvas if flipping fails
+     */
+    private flipCanvasVertically;
+    /**
+     * Creates a flipped ImageBitmap from RGBA data.
+     * Uses ImageBitmap for better performance when available.
+     *
+     * @param rgbaData - The RGBA pixel data
+     * @param sampleSize - Size of the tile (width and height)
+     * @returns A flipped ImageBitmap, or undefined if creation fails
+     */
+    private createFlippedImageBitmap;
+    /**
+     * Creates a flipped image (ImageBitmap or Canvas) from RGBA data.
+     * Prefers ImageBitmap for better performance, falls back to Canvas.
+     *
+     * @param rgbaData - The RGBA pixel data
+     * @returns A flipped ImageBitmap or Canvas, or undefined if creation fails
+     */
+    private createFlippedImageFromRGBA;
+    requestImage(x: number, y: number, level: number): Promise<HTMLCanvasElement | ImageBitmap | undefined>;
+    pickFeatures(): undefined;
+}
+export {};

package/dist/types/map-provider/cesium/GeoTIFFImageryProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/map-provider/cesium/cesium-provider.d.ts

@@ -0,0 +1,87 @@
+import type { MapProvider, LayerUpdate, LayerErrorCallback } from '../../types/mapprovider';
+import type { ProviderOptions } from '../../types/provideroptions';
+import type { LayerConfig } from '../../types/layerconfig';
+import type { LonLat } from '../../types/lonlat';
+export declare class CesiumProvider implements MapProvider {
+    private viewer;
+    private Cesium;
+    private layerManager;
+    private shadowRoot;
+    private layerGroups;
+    private layerManagerMutex;
+    private layerErrorCallbacks;
+    private layerErrorCleanups;
+    init(options: ProviderOptions): Promise<void>;
+    destroy(): Promise<void>;
+    private createLayer;
+    addLayerToGroup(layerConfig: LayerConfig): Promise<string>;
+    setBaseLayer(groupId: string, layerElementId: string): Promise<void>;
+    addBaseLayer(layerConfig: LayerConfig, basemapid: string, layerElementId: string): Promise<string>;
+    ensureGroup(groupId: string, visible: boolean, _opts?: {
+        basemapid?: string;
+    }): Promise<void>;
+    setGroupVisible(groupId: string, visible: boolean): Promise<void>;
+    onLayerError(layerId: string, callback: LayerErrorCallback): void;
+    offLayerError(layerId: string): void;
+    private attachCesiumErrorListeners;
+    removeLayer(layerId: string): Promise<void>;
+    setOpacity(layerId: string, opacity: number): Promise<void>;
+    setVisible(layerId: string, visible: boolean): Promise<void>;
+    setZIndex(layerId: string, zIndex: number): Promise<void>;
+    /**
+     * Apply Geostyler styling to a GeoJsonDataSource
+     */
+    private applyGeostylerStyling;
+    /**
+     * Convert CSS color to Cesium Color
+     */
+    private parseCesiumColor;
+    /**
+     * Apply opacity to Cesium color
+     */
+    private applyCesiumOpacity;
+    /**
+     * Create Cesium styling options from StyleConfig
+     */
+    private createCesiumStyle;
+    /**
+     * Apply enhanced styling to a GeoJsonDataSource
+     */
+    private applyEnhancedStyling;
+    private createWKTLayer;
+    private wktToGeoJSON;
+    private resolveWktText;
+    private createGeoJSONLayer;
+    private createWFSLayer;
+    private createOSMLayer;
+    private createGoogleLayer;
+    private getGoogleMapTypeId;
+    /**
+     * Load Google Maps JavaScript API
+     */
+    private loadGoogleMapsApi;
+    /**
+     * Add Google logo for compliance
+     */
+    private ensureGoogleLogo;
+    private createXYZLayer;
+    private createTerrainLayer;
+    /**
+     * Create GeoTIFF Terrain Layer
+     * Loads GeoTIFF elevation data and provides it as terrain
+     */
+    private createGeoTIFFTerrainLayer;
+    private addWMSLayer;
+    /**
+     * Create WCS (Web Coverage Service) ImageryLayer
+     * Supports WCS 2.0.1 (subset) and 1.x.x (BBOX) versions
+     */
+    private createWCSLayer;
+    private addArcGISLayer;
+    private createGeoTIFFLayer;
+    private createTile3DLayer;
+    updateLayer(layerId: string, update: LayerUpdate): Promise<void>;
+    setView(center: LonLat, zoom: number): Promise<void>;
+    private fetchWFSFromUrl;
+    private appendParams;
+}

package/dist/types/map-provider/cesium/i-layer.d.ts

@@ -0,0 +1,11 @@
+export interface ILayer {
+    getOptions(): Record<string, unknown>;
+    setOptions(options: Record<string, unknown>): void;
+    getVisible(): boolean;
+    setVisible(value: boolean): void;
+    getOpacity(): number;
+    setOpacity(value: number): void;
+    getZIndex(): number;
+    setZIndex(zIndex: number): Promise<void>;
+    remove(): void;
+}

package/dist/types/map-provider/cesium/layer-manager.d.ts

@@ -0,0 +1,31 @@
+import type { Viewer, Cesium3DTileset, ImageryLayer, DataSource, Color, Cesium3DTileStyle, GeoJsonDataSource } from 'cesium';
+import { ILayer } from './i-layer';
+interface I3DTilesLayer extends ILayer {
+    setColor(color: string | Color, opacity?: number): void;
+    setStyle(style: Cesium3DTileStyle | Record<string, unknown>): void;
+}
+type CesiumModule = typeof import('cesium');
+export declare class LayerManager {
+    private Cesium;
+    private layers;
+    private viewer;
+    constructor(Cesium: CesiumModule, viewer: Viewer);
+    replaceLayer<T extends GeoJsonDataSource | DataSource | Cesium3DTileset | ImageryLayer>(id: string, oldlayer: ILayer | I3DTilesLayer, layer: T): ILayer | I3DTilesLayer;
+    addLayer<T extends GeoJsonDataSource | DataSource | Cesium3DTileset | ImageryLayer>(id: string, layer: T): ILayer | I3DTilesLayer;
+    addCustomLayer(id: string, layer: ILayer | I3DTilesLayer): ILayer | I3DTilesLayer;
+    getLayer(layerId: string): ILayer | I3DTilesLayer;
+    getLayerById(layerId: string): ILayer | I3DTilesLayer;
+    removeLayer(layerId: string): void;
+    setVisible(layerId: string, visible: boolean): void;
+    setOpacity(layerId: string, opacity: number): void;
+    setZIndex(layerId: string, zindex: number): Promise<void>;
+    private wrapLayer;
+    private sortImageryLayers;
+    private sort3DTileSets;
+    private sortDataSources;
+    private sort;
+    private wrapImageryLayer;
+    private wrapTilesetLayer;
+    private wrapDataSourceLayer;
+}
+export {};

package/dist/types/map-provider/deck/DeckGLGeoTIFFLayer.d.ts

@@ -0,0 +1,91 @@
+import type { Layer, LayerProps } from '@deck.gl/core';
+import type { ColorMap as GeoStylerColorMap } from 'geostyler-style';
+import { type ColorMapName } from '../geotiff/utils/colormap-utils';
+export interface DeckGLGeoTIFFLayerProps extends LayerProps {
+    url: string;
+    /**
+     * Quell-Projektion des GeoTIFF (z. B. "EPSG:32632" oder proj4-String)
+     *
+     * Verwendung:
+     * 1. Wenn nicht angegeben: Projektion wird aus GeoTIFF GeoKeys gelesen
+     * 2. Wenn GeoKeys fehlen: Dieser Wert wird als Fallback verwendet
+     * 3. Wenn forceProjection=true: Überschreibt GeoKeys komplett
+     *
+     * Default fallback: 'EPSG:4326' (WGS84)
+     */
+    projection?: string;
+    /**
+     * Erzwingt die Verwendung der projection-Prop, ignoriert GeoKeys
+     *
+     * Nützlich wenn:
+     * - GeoTIFF falsche/fehlende Projektionsinformationen hat
+     * - Man die Projektion manuell überschreiben möchte
+     *
+     * Default: false
+     */
+    forceProjection?: boolean;
+    noDataValue?: number;
+    nullColor?: [number, number, number, number];
+    minZoom?: number;
+    maxZoom?: number;
+    tileSize?: number;
+    /**
+     * Sampling-Auflösung (0.0 - 1.0)
+     *
+     * - 1.0 = volle Auflösung (256x256 samples für 256x256 tile)
+     * - 0.5 = halbe Auflösung (128x128 samples, upscaled zu 256x256)
+     * - 0.25 = viertel Auflösung (64x64 samples, upscaled zu 256x256)
+     *
+     * Niedrigere Werte = schneller, aber weniger genau
+     * Default: 1.0
+     */
+    resolution?: number;
+    /**
+     * Resampling-Methode
+     *
+     * - 'near': Nearest Neighbor (schnellste, blockartig)
+     * - 'bilinear': Bilineare Interpolation (langsamer, glatter)
+     *
+     * Default: 'bilinear'
+     */
+    resampleMethod?: 'near' | 'bilinear';
+    /**
+     * ColorMap für Grayscale-Daten
+     *
+     * Unterstützt:
+     * 1. Vordefinierte Namen:
+     *    - 'grayscale': Schwarz-Weiß (default)
+     *    - 'viridis': Wissenschaftliche Farbskala (lila→gelb)
+     *    - 'terrain': Terrain-Farben (blau→grün→braun→weiß)
+     *    - 'turbo': Google Turbo (blau→grün→gelb→rot)
+     *    - 'rainbow': Regenbogen
+     *
+     * 2. GeoStyler ColorMap (aus SLD via v-map-style):
+     *    Wird automatisch vom styleReady Event übernommen
+     *
+     * Nur für Single-Band (Grayscale) Daten!
+     * RGB/RGBA Daten ignorieren diese Prop.
+     *
+     * Default: 'grayscale'
+     */
+    colorMap?: ColorMapName | GeoStylerColorMap;
+    /**
+     * Wertebereich für Normalisierung [min, max]
+     *
+     * Für Float32/Float64 Daten: Mappt Werte in diesem Bereich auf 0-1 für ColorMap
+     * - Werte < min → 0.0 (erste Farbe)
+     * - Werte > max → 1.0 (letzte Farbe)
+     * - Dazwischen → linear interpoliert
+     *
+     * Wenn nicht angegeben: Auto-detect aus Daten (kann langsam sein!)
+     *
+     * Beispiel: [0, 3000] für Höhendaten 0-3000m
+     */
+    valueRange?: [number, number];
+    /** Optional callback for tile load errors, wired by provider. */
+    onTileLoadError?: (err: Error) => void;
+}
+/**
+ * Factory-Funktion zum Erstellen eines DeckGLGeoTIFFLayer
+ */
+export declare function createDeckGLGeoTIFFLayer(props: DeckGLGeoTIFFLayerProps): Promise<Layer>;