import * as _angular_core from '@angular/core';
import { InjectionToken, OnInit, ElementRef } from '@angular/core';
import OLMap from 'ol/Map';
import { OlFeature } from '@angular-helpers/openlayers/core';

declare class OlZoomControlComponent {
    private mapService;
    private zoneHelper;
    delta: _angular_core.InputSignal<number>;
    duration: _angular_core.InputSignal<number>;
    private control?;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlZoomControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlZoomControlComponent, "ol-zoom-control", never, { "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OlAttributionControlComponent {
    private mapService;
    private zoneHelper;
    collapsible: _angular_core.InputSignal<boolean>;
    collapsed: _angular_core.InputSignal<boolean>;
    private control?;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlAttributionControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlAttributionControlComponent, "ol-attribution-control", never, { "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OlScaleLineControlComponent {
    private mapService;
    private zoneHelper;
    units: _angular_core.InputSignal<"metric" | "imperial" | "nautical" | "us">;
    bar: _angular_core.InputSignal<boolean>;
    steps: _angular_core.InputSignal<number>;
    private control?;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlScaleLineControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlScaleLineControlComponent, "ol-scale-line-control", never, { "units": { "alias": "units"; "required": false; "isSignal": true; }; "bar": { "alias": "bar"; "required": false; "isSignal": true; }; "steps": { "alias": "steps"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OlFullscreenControlComponent {
    private mapService;
    private zoneHelper;
    source: _angular_core.InputSignal<HTMLElement | undefined>;
    label: _angular_core.InputSignal<string>;
    labelActive: _angular_core.InputSignal<string>;
    tipLabel: _angular_core.InputSignal<string>;
    private control?;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlFullscreenControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlFullscreenControlComponent, "ol-fullscreen-control", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelActive": { "alias": "labelActive"; "required": false; "isSignal": true; }; "tipLabel": { "alias": "tipLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Interface for map service that rotate control needs
 * Implement this or provide your OlMapService using this token
 */
interface RotateControlMapService {
    getMap(): OLMap | null;
    onReady(callback: (map: OLMap) => void): void;
}
/**
 * Injection token for map service used by rotate control
 * Consumers should provide their OlMapService using this token:
 * ```ts
 * { provide: ROTATE_CONTROL_MAP_SERVICE, useExisting: OlMapService }
 * ```
 */
declare const ROTATE_CONTROL_MAP_SERVICE: InjectionToken<RotateControlMapService>;
declare class OlRotateControlComponent {
    private mapService;
    private zoneHelper;
    autoHide: _angular_core.InputSignal<boolean>;
    duration: _angular_core.InputSignal<number>;
    tipLabel: _angular_core.InputSignal<string>;
    private control?;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlRotateControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlRotateControlComponent, "ol-rotate-control", never, { "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "tipLabel": { "alias": "tipLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Item representing a layer in the layer switcher UI
 */
interface LayerSwitcherItem {
    /** Unique identifier for the layer */
    id: string;
    /** Display name for the layer */
    name: string;
    /** Type of the layer */
    type: 'vector' | 'tile' | 'image' | 'heatmap';
    /** Whether the layer is currently visible */
    visible: boolean;
    /** Opacity of the layer (0-1) */
    opacity: number;
}
/**
 * Position options for the layer switcher control
 */
type LayerSwitcherPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';

/**
 * A reusable layer switcher control that displays all layers
 * and allows toggling their visibility.
 *
 * @usageNotes
 * ```html
 * <ol-layer-switcher
 *   position="top-right"
 *   [layers]="layerItems()"
 *   [collapsible]="true"
 *   [showOpacity]="true"
 *   (visibilityChange)="onVisibilityChange($event)"
 *   (opacityChange)="onOpacityChange($event)">
 * </ol-layer-switcher>
 * ```
 */
declare class OlLayerSwitcherComponent implements OnInit {
    position: _angular_core.InputSignal<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
    layers: _angular_core.InputSignal<LayerSwitcherItem[]>;
    collapsible: _angular_core.InputSignal<boolean>;
    showOpacity: _angular_core.InputSignal<boolean>;
    startCollapsed: _angular_core.InputSignal<boolean>;
    visibilityChange: _angular_core.OutputEmitterRef<{
        id: string;
        visible: boolean;
    }>;
    opacityChange: _angular_core.OutputEmitterRef<{
        id: string;
        opacity: number;
    }>;
    protected isCollapsed: _angular_core.WritableSignal<boolean>;
    ngOnInit(): void;
    toggleCollapsed(): void;
    toggleLayer(id: string): void;
    setOpacity(id: string, event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlLayerSwitcherComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlLayerSwitcherComponent, "ol-layer-switcher", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "layers": { "alias": "layers"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "showOpacity": { "alias": "showOpacity"; "required": false; "isSignal": true; }; "startCollapsed": { "alias": "startCollapsed"; "required": false; "isSignal": true; }; }, { "visibilityChange": "visibilityChange"; "opacityChange": "opacityChange"; }, never, never, true, never>;
}

/**
 * Configuration for a basemap (background layer)
 */
interface BasemapConfig {
    /** Unique identifier for the basemap */
    id: string;
    /** Display name for the basemap */
    name: string;
    /** Type of tile source */
    type: 'osm' | 'xyz' | 'wms';
    /** URL template for XYZ/WMS sources */
    url?: string;
    /** Additional parameters for WMS requests */
    params?: Record<string, unknown>;
    /** Attribution text */
    attributions?: string | string[];
    /** Optional icon/emoji */
    icon?: string;
}
/**
 * Position options for the basemap switcher control
 */
type BasemapSwitcherPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';

/**
 * A basemap switcher control that allows switching between
 * different tile providers without page refresh.
 *
 * @usageNotes
 * ```html
 * <ol-basemap-switcher
 *   position="bottom-left"
 *   [basemaps]="[
 *     { id: 'osm', name: 'OpenStreetMap', type: 'osm' },
 *     { id: 'satellite', name: 'Satellite', type: 'xyz', url: 'https://...' }
 *   ]"
 *   [activeBasemap]="'osm'"
 *   (basemapChange)="onBasemapChange($event)">
 * </ol-basemap-switcher>
 * ```
 */
declare class OlBasemapSwitcherComponent {
    basemaps: _angular_core.InputSignal<BasemapConfig[]>;
    activeBasemap: _angular_core.InputSignal<string>;
    position: _angular_core.InputSignal<BasemapSwitcherPosition>;
    basemapChange: _angular_core.OutputEmitterRef<string>;
    protected isExpanded: _angular_core.WritableSignal<boolean>;
    toggleExpanded(): void;
    switchBasemap(basemap: BasemapConfig): void;
    getActiveBasemapName(): string;
    getDefaultIcon(basemap: BasemapConfig): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlBasemapSwitcherComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlBasemapSwitcherComponent, "ol-basemap-switcher", never, { "basemaps": { "alias": "basemaps"; "required": false; "isSignal": true; }; "activeBasemap": { "alias": "activeBasemap"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "basemapChange": "basemapChange"; }, never, never, true, never>;
}

type ControlPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'left-center' | 'right-center';
interface ControlConfig {
    position?: ControlPosition;
    className?: string;
}

declare class OlGeolocationControlComponent {
    private mapService;
    private zoneHelper;
    private destroyRef;
    position: _angular_core.InputSignal<ControlPosition>;
    trackingChange: _angular_core.OutputEmitterRef<boolean>;
    controlElement: _angular_core.Signal<ElementRef<HTMLElement>>;
    protected tracking: _angular_core.WritableSignal<boolean>;
    private control?;
    private geolocation?;
    private positionFeature?;
    private accuracyFeature?;
    private layer?;
    constructor();
    toggleTracking(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlGeolocationControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlGeolocationControlComponent, "ol-geolocation-control", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "trackingChange": "trackingChange"; }, never, never, true, never>;
}

declare class OlControlService {
    addCustomControl(_element: HTMLElement, _position: ControlPosition): void;
    removeCustomControl(_element: HTMLElement): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlControlService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlControlService>;
}

/**
 * Provides control services and configures the rotate control map service alias.
 * Requires OlMapService to be provided at the application level.
 */
declare function withControls(): OlFeature<'controls'>;
declare function provideControls(): OlFeature<'controls'>;

type TimelinePosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';

/**
 * A premium, reactive visual timeline component for OpenLayers.
 * Orchestrates time-series animations by binding directly to OlTimeService.
 *
 * Uses native controls, CSS grid/flex layouts, and a sleek glassmorphic theme.
 * Completely free of CommonModule or FormsModule dependencies for maximum performance.
 *
 * @usageNotes
 * ```html
 * <ol-timeline
 *   [startTime]="1700000000000"
 *   [endTime]="1700086400000"
 *   [playSpeed]="60"
 *   [loop]="true"
 *   position="bottom-center">
 * </ol-timeline>
 * ```
 */
declare class OlTimelineComponent {
    private timeService;
    /** Start bounds of time-series (Epoch ms) */
    startTime: _angular_core.InputSignal<number>;
    /** End bounds of time-series (Epoch ms) */
    endTime: _angular_core.InputSignal<number>;
    /** Default speed multiplier (e.g. 1, 5, 10, 60, 3600) */
    playSpeed: _angular_core.InputSignal<number>;
    /** Loop playback when reaching endTime */
    loop: _angular_core.InputSignal<boolean>;
    /** Position overlay alignment */
    position: _angular_core.InputSignal<TimelinePosition>;
    /** Custom label formatter */
    formatLabel: _angular_core.InputSignal<(time: number) => string>;
    /** Outputs */
    timeChange: _angular_core.OutputEmitterRef<number>;
    playStateChange: _angular_core.OutputEmitterRef<boolean>;
    /** Computeds binding directly to OlTimeService */
    currentTime: _angular_core.Signal<number>;
    isPlaying: _angular_core.Signal<boolean>;
    speed: _angular_core.Signal<number>;
    formattedTime: _angular_core.Signal<string>;
    constructor();
    togglePlay(): void;
    onScrub(event: Event): void;
    onSpeedChange(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlTimelineComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlTimelineComponent, "ol-timeline", never, { "startTime": { "alias": "startTime"; "required": true; "isSignal": true; }; "endTime": { "alias": "endTime"; "required": true; "isSignal": true; }; "playSpeed": { "alias": "playSpeed"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "formatLabel": { "alias": "formatLabel"; "required": false; "isSignal": true; }; }, { "timeChange": "timeChange"; "playStateChange": "playStateChange"; }, never, never, true, never>;
}

export { OlAttributionControlComponent, OlBasemapSwitcherComponent, OlControlService, OlFullscreenControlComponent, OlGeolocationControlComponent, OlLayerSwitcherComponent, OlRotateControlComponent, OlScaleLineControlComponent, OlTimelineComponent, OlZoomControlComponent, ROTATE_CONTROL_MAP_SERVICE, provideControls, withControls };
export type { BasemapConfig, BasemapSwitcherPosition, ControlConfig, ControlPosition, LayerSwitcherItem, LayerSwitcherPosition, RotateControlMapService, TimelinePosition };