import * as ol from 'ol';
import * as ol_geom from 'ol/geom';
import * as _angular_core from '@angular/core';
import { Layer, Extent, Feature, Style, OlFeature } from '@angular-helpers/openlayers/core';
import FeatureFormat from 'ol/format/Feature';
import OLFeature from 'ol/Feature';
import { FlatStyleLike } from 'ol/style/flat';
import { Style as Style$1 } from 'ol/layer/WebGLTile';
import BaseLayer from 'ol/layer/Base';

interface LayerConfig extends Layer {
    type: 'vector' | 'tile' | 'image' | 'heatmap';
    extent?: Extent;
    minResolution?: number;
    maxResolution?: number;
}
interface ClusterConfig {
    /** Enable clustering (default: false) */
    enabled: boolean;
    /** Distance in pixels within which features will be clustered (default: 40) */
    distance?: number;
    /** Minimum distance between clusters (default: 20) */
    minDistance?: number;
    /** Show count badge on cluster (default: true) */
    showCount?: boolean;
    /** Style for individual features when clustering */
    featureStyle?: Style;
    /** Automatically spiderfy overlapping points on click (default: false) */
    spiderfyOnSelect?: boolean;
    /** Callback when a spider leg feature is clicked */
    onSpiderfyClick?: (feature: Feature) => void;
}
interface AutoFitOptions {
    padding?: number[];
    duration?: number;
}
interface VectorSourceConfig {
    features?: Feature[];
    url?: string;
    format?: 'geojson' | 'topojson' | 'kml' | FeatureFormat;
    coordinateProjection?: string;
    autoFit?: boolean | AutoFitOptions;
    onError?: (error: Error) => void;
    onFeaturesLoaded?: (features: Feature[]) => void;
    throttleTime?: number;
}
interface VectorLayerConfig extends LayerConfig, VectorSourceConfig {
    type: 'vector';
    style?: Style | ((feature: Feature) => Style);
    cluster?: ClusterConfig;
}
interface HeatmapLayerConfig extends LayerConfig {
    type: 'heatmap';
    features?: Feature[];
    weight?: string | ((feature: Feature) => number);
    blur?: number;
    radius?: number;
}
interface TileLayerConfig extends LayerConfig {
    type: 'tile';
    source: SourceConfig;
}
interface ImageLayerConfig extends LayerConfig {
    type: 'image';
    source: ImageSourceConfig;
}
interface SourceConfig {
    type: 'osm' | 'xyz' | 'wms' | 'wmts';
    url?: string;
    attributions?: string | string[];
    params?: Record<string, unknown>;
}
interface ImageSourceConfig {
    type: 'wms' | 'static';
    url: string;
    params?: Record<string, unknown>;
    imageExtent?: Extent;
}
type AnyLayerConfig = VectorLayerConfig | TileLayerConfig | ImageLayerConfig | HeatmapLayerConfig;

declare class OlClusterComponent {
    distance: _angular_core.InputSignal<number>;
    minDistance: _angular_core.InputSignal<number>;
    showCount: _angular_core.InputSignal<boolean>;
    featureStyle: _angular_core.InputSignal<Style | undefined>;
    spiderfyOnSelect: _angular_core.InputSignal<boolean>;
    spiderfyClick: _angular_core.OutputEmitterRef<Feature>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlClusterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlClusterComponent, "ol-cluster", never, { "distance": { "alias": "distance"; "required": false; "isSignal": true; }; "minDistance": { "alias": "minDistance"; "required": false; "isSignal": true; }; "showCount": { "alias": "showCount"; "required": false; "isSignal": true; }; "featureStyle": { "alias": "featureStyle"; "required": false; "isSignal": true; }; "spiderfyOnSelect": { "alias": "spiderfyOnSelect"; "required": false; "isSignal": true; }; }, { "spiderfyClick": "spiderfyClick"; }, never, never, true, never>;
}

declare class OlVectorLayerComponent {
    private layerService;
    private mapService;
    private destroyRef;
    id: _angular_core.InputSignal<string>;
    source: _angular_core.InputSignal<string | VectorSourceConfig | Feature[] | undefined>;
    features: _angular_core.InputSignal<Feature[] | undefined>;
    url: _angular_core.InputSignal<string | undefined>;
    format: _angular_core.InputSignal<FeatureFormat<ol.Feature<ol_geom.Geometry, {
        [x: string]: any;
    }>> | "geojson" | "topojson" | "kml" | undefined>;
    zIndex: _angular_core.InputSignal<number>;
    opacity: _angular_core.InputSignal<number>;
    visible: _angular_core.InputSignal<boolean>;
    style: _angular_core.InputSignal<any>;
    cluster: _angular_core.InputSignal<ClusterConfig | undefined>;
    clusterComponent: _angular_core.Signal<OlClusterComponent | undefined>;
    coordinateProjection: _angular_core.InputSignal<string>;
    autoFit: _angular_core.InputSignal<boolean | AutoFitOptions>;
    readonly resolvedSourceConfig: _angular_core.Signal<VectorSourceConfig>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlVectorLayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlVectorLayerComponent, "ol-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "cluster": { "alias": "cluster"; "required": false; "isSignal": true; }; "coordinateProjection": { "alias": "coordinateProjection"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; }, {}, ["clusterComponent"], never, true, never>;
}

declare class OlTileLayerComponent {
    private layerService;
    private destroyRef;
    id: _angular_core.InputSignal<string>;
    source: _angular_core.InputSignal<"osm" | "xyz" | "wms">;
    url: _angular_core.InputSignal<string | undefined>;
    attributions: _angular_core.InputSignal<string | string[] | undefined>;
    params: _angular_core.InputSignal<Record<string, unknown> | undefined>;
    zIndex: _angular_core.InputSignal<number>;
    opacity: _angular_core.InputSignal<number>;
    visible: _angular_core.InputSignal<boolean>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlTileLayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlTileLayerComponent, "ol-tile-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "attributions": { "alias": "attributions"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OlImageLayerComponent {
    private layerService;
    private destroyRef;
    id: _angular_core.InputSignal<string>;
    sourceType: _angular_core.InputSignal<"wms" | "static">;
    url: _angular_core.InputSignal<string>;
    params: _angular_core.InputSignal<Record<string, unknown> | undefined>;
    imageExtent: _angular_core.InputSignal<[number, number, number, number] | undefined>;
    zIndex: _angular_core.InputSignal<number>;
    opacity: _angular_core.InputSignal<number>;
    visible: _angular_core.InputSignal<boolean>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlImageLayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlImageLayerComponent, "ol-image-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "sourceType": { "alias": "sourceType"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": true; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "imageExtent": { "alias": "imageExtent"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OlHeatmapLayerComponent {
    private layerService;
    private mapService;
    private destroyRef;
    id: _angular_core.InputSignal<string>;
    features: _angular_core.InputSignal<Feature[]>;
    zIndex: _angular_core.InputSignal<number>;
    opacity: _angular_core.InputSignal<number>;
    visible: _angular_core.InputSignal<boolean>;
    blur: _angular_core.InputSignal<number>;
    radius: _angular_core.InputSignal<number>;
    /** Unit for radius and blur: 'pixels' (default) or 'meters' */
    radiusUnit: _angular_core.InputSignal<"pixels" | "meters">;
    weight: _angular_core.InputSignal<string | ((feature: Feature) => number) | undefined>;
    /** Computed radius in pixels based on current resolution if unit is 'meters' */
    private scaledRadius;
    /** Computed blur in pixels based on current resolution if unit is 'meters' */
    private scaledBlur;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlHeatmapLayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlHeatmapLayerComponent, "ol-heatmap-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "radiusUnit": { "alias": "radiusUnit"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * GPU-accelerated vector layer for rendering large datasets.
 *
 * Important: Uses WebGL 2 for rendering. Styles must be provided as
 * `FlatStyleLike` objects (not `ol/style/Style` instances).
 * Hit detection is disabled by default for performance.
 *
 * @usageNotes
 * ```html
 * <ol-webgl-vector-layer
 *   id="big-dataset"
 *   [features]="largeDataset()"
 *   [flatStyle]="{
 *     'circle-radius': 6,
 *     'circle-fill-color': ['match', ['get', 'type'], 'alert', 'red', 'blue'],
 *     'stroke-color': '#333',
 *     'stroke-width': 1
 *   }"
 *   [disableHitDetection]="true">
 * </ol-webgl-vector-layer>
 * ```
 */
declare class OlWebGLVectorLayerComponent {
    private mapService;
    private zoneHelper;
    private destroyRef;
    /** Unique layer identifier */
    id: _angular_core.InputSignal<string>;
    /** Polymorphic vector source configuration */
    source: _angular_core.InputSignal<string | VectorSourceConfig | Feature[] | undefined>;
    /** Features to render */
    features: _angular_core.InputSignal<Feature[]>;
    /** Remote URL */
    url: _angular_core.InputSignal<string | undefined>;
    /** Format specification */
    format: _angular_core.InputSignal<FeatureFormat<OLFeature<ol_geom.Geometry, {
        [x: string]: any;
    }>> | "geojson" | "topojson" | "kml" | undefined>;
    /** Data coordinate projection */
    coordinateProjection: _angular_core.InputSignal<string>;
    /** Auto fit options */
    autoFit: _angular_core.InputSignal<boolean | AutoFitOptions>;
    /** WebGL flat style (required — no default provided) */
    flatStyle: _angular_core.InputSignal<FlatStyleLike>;
    /** Z-index for layer ordering */
    zIndex: _angular_core.InputSignal<number>;
    /** Opacity (0–1) */
    opacity: _angular_core.InputSignal<number>;
    /** Layer visibility */
    visible: _angular_core.InputSignal<boolean>;
    /** Disable hit detection for better performance (default: true) */
    disableHitDetection: _angular_core.InputSignal<boolean>;
    /** Style variables for dynamic expressions (e.g. `['var', 'threshold']`) */
    variables: _angular_core.InputSignal<Record<string, string | number | boolean | number[]> | undefined>;
    readonly resolvedSourceConfig: _angular_core.Signal<VectorSourceConfig>;
    private layer;
    private vectorSource;
    constructor();
    /**
     * Imperatively update style variables without triggering Angular change detection.
     * Ideal for 60FPS animations (e.g., linked to OlTimeService) where you don't want
     * to use the declarative [variables] input.
     */
    updateVariables(vars: Record<string, string | number | boolean | number[]>): void;
    private syncFeatures;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlWebGLVectorLayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlWebGLVectorLayerComponent, "ol-webgl-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "coordinateProjection": { "alias": "coordinateProjection"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "flatStyle": { "alias": "flatStyle"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "disableHitDetection": { "alias": "disableHitDetection"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * GPU-accelerated tile layer with color/brightness/contrast expressions.
 *
 * Supports the same tile sources as `ol-tile-layer` but renders via WebGL,
 * enabling GPU-powered color manipulation (brightness, contrast, saturation, gamma).
 *
 * @usageNotes
 * ```html
 * <ol-webgl-tile-layer
 *   id="satellite-webgl"
 *   source="xyz"
 *   [url]="'https://server.arcgisonline.com/.../{z}/{y}/{x}'"
 *   [tileStyle]="{ brightness: 0.1, contrast: 0.2 }">
 * </ol-webgl-tile-layer>
 * ```
 */
declare class OlWebGLTileLayerComponent {
    private mapService;
    private zoneHelper;
    private destroyRef;
    /** Unique layer identifier */
    id: _angular_core.InputSignal<string>;
    /** Tile source type */
    source: _angular_core.InputSignal<"osm" | "xyz" | "mvt">;
    /** Tile URL template (required for 'xyz' and 'mvt') */
    url: _angular_core.InputSignal<string | undefined>;
    /** Attribution text */
    attributions: _angular_core.InputSignal<string | string[] | undefined>;
    /** WebGL tile style (raster expressions) or flat style (MVT) */
    tileStyle: _angular_core.InputSignal<FlatStyleLike | Style$1 | undefined>;
    /** Z-index for layer ordering */
    zIndex: _angular_core.InputSignal<number>;
    /** Opacity (0–1) */
    opacity: _angular_core.InputSignal<number>;
    /** Layer visibility */
    visible: _angular_core.InputSignal<boolean>;
    /** Preload low-res tiles up to this many zoom levels */
    preload: _angular_core.InputSignal<number>;
    /** Style variables for dynamic expressions (e.g. `['var', 'brightness']`) */
    variables: _angular_core.InputSignal<Record<string, string | number | boolean | number[]> | undefined>;
    private layer;
    private sourceInstance;
    constructor();
    /**
     * Imperatively update style variables without triggering Angular change detection.
     * Ideal for 60FPS animations where you don't want to use the declarative [variables] input.
     */
    updateVariables(vars: Record<string, string | number | boolean | number[]>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlWebGLTileLayerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlWebGLTileLayerComponent, "ol-webgl-tile-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "attributions": { "alias": "attributions"; "required": false; "isSignal": true; }; "tileStyle": { "alias": "tileStyle"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "preload": { "alias": "preload"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface LayerInfo {
    id: string;
    type: 'vector' | 'tile' | 'image' | 'heatmap';
    visible: boolean;
    opacity: number;
    zIndex: number;
}
declare class OlLayerService {
    private mapService;
    private zoneHelper;
    private layerCache;
    private pendingConfigs;
    private layerState;
    private spiderManager;
    readonly layers: _angular_core.Signal<LayerInfo[]>;
    readonly visibleLayers: _angular_core.Signal<LayerInfo[]>;
    readonly tileLayers: _angular_core.Signal<LayerInfo[]>;
    readonly vectorLayers: _angular_core.Signal<LayerInfo[]>;
    addLayer(config: AnyLayerConfig): {
        id: string;
    };
    private flushPending;
    private createVectorSource;
    private createLayer;
    getLayer(id: string): BaseLayer | undefined;
    hasLayer(id: string): boolean;
    removeLayer(id: string): void;
    updateVectorLayerConfig(id: string, config: Partial<VectorLayerConfig>): void;
    setVisibility(id: string, visible: boolean): void;
    toggleVisibility(id: string): boolean;
    setOpacity(id: string, opacity: number): void;
    setZIndex(id: string, zIndex: number): void;
    setClusterDistance(id: string, distance: number): void;
    setClusterMinDistance(id: string, minDistance: number): void;
    setHeatmapProperties(id: string, props: {
        blur?: number;
        radius?: number;
        weight?: string | ((feature: any) => number);
    }): void;
    isVisible(id: string): boolean;
    getOpacity(id: string): number;
    getZIndex(id: string): number;
    clearFeatures(id: string): void;
    updateFeatures(id: string, features: VectorLayerConfig['features']): void;
    fitToLayer(id: string, options?: AutoFitOptions): void;
    private updateLayerState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlLayerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlLayerService>;
}

declare function withLayers(): OlFeature<'layers'>;
declare function provideLayers(): OlFeature<'layers'>;

export { OlClusterComponent, OlHeatmapLayerComponent, OlImageLayerComponent, OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, OlWebGLTileLayerComponent, OlWebGLVectorLayerComponent, provideLayers, withLayers };
export type { HeatmapLayerConfig, ImageLayerConfig, ImageSourceConfig, LayerConfig, LayerInfo, SourceConfig, TileLayerConfig, VectorLayerConfig };