import * as i0 from '@angular/core';
import { OnInit, AfterViewInit, OnChanges, SimpleChanges, DoCheck } from '@angular/core';
import * as i1 from '@angular/common';
import * as i2 from '@angular/forms';
import * as i3 from '@helgoland/core';
import { HelgolandServicesConnector, HelgolandParameterFilter, HelgolandPlatform } from '@helgoland/core';
import { Layer } from 'ol/layer';
import BaseLayer from 'ol/layer/Base';
import { TileWMS } from 'ol/source';
import { Observable } from 'rxjs';
import { Map } from 'ol';
import Map$1 from 'ol/Map.js';

/**
 * Legend component to display the abstract, gathered by the WMS capabilities
 */
declare class OlLayerAbstractComponent implements OnInit {
    private wmsCaps;
    readonly layer: i0.InputSignal<Layer>;
    abstract: string | undefined;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerAbstractComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerAbstractComponent, "n52-ol-layer-abstract", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface WMSLayer {
    name: string;
    title: string;
    abstract: string;
    childLayer: WMSLayer[];
}
/**
 * Handler for WMS capabilities
 */
declare class WmsCapabilitiesService {
    private http;
    /**
     * Returns the layer title of the capabilities as observable
     *
     * @param layerName
     * @param wmsurl
     * @returns layer title as string observable
     */
    getTitle(layerName: string, wmsurl: string): Observable<string>;
    /**
     * Returns the layer abstract of the capabilities as observable
     *
     * @param layerName
     * @param wmsurl
     * @returns layer abstract as string observable
     */
    getAbstract(layerName: string, wmsurl: string): Observable<string>;
    /**
     * Returns a date array as observable for the given layername, if available
     *
     * @param layerName
     * @param wmsurl
     * @returns
     */
    getTimeDimensionArray(layerName: string, wmsurl: string): Observable<Date[]>;
    /**
     * Returns a legend url as observable, if available
     *
     * @param layerName
     * @param wmsurl
     * @returns
     */
    getLegendUrl(layerName: string, wmsurl: string): Observable<string>;
    /**
     * Returns the default date as observable for the given layername, if available
     *
     * @param layerName
     * @param wmsurl
     * @returns
     */
    getDefaultTimeDimension(layerName: string, wmsurl: string): Observable<Date | undefined>;
    /**
     * Returns the extent as observable for the given layername and epsg code, if available
     *
     * @param layerName
     * @param wmsurl
     * @param epsgCode
     * @returns
     */
    getExtent(layerName: string, wmsurl: string, epsgCode: string): Observable<{
        crs: string;
        extent: number[];
    } | undefined>;
    getLayerTree(wmsurl: string): Observable<WMSLayer>;
    /**
     * Removes every request parameter of the url an returns this cleand url.
     */
    cleanUpWMSUrl(url: string): string;
    private createLayer;
    private getCapabilities;
    private findLayerByName;
    private getLayerInfo;
    private fixExtent;
    private createTimeList;
    private findNearestTimestamp;
    static ɵfac: i0.ɵɵFactoryDeclaration<WmsCapabilitiesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WmsCapabilitiesService>;
}

/**
 * Legend component to select time stamps of a layer, the time information is gathered by the WMS capabilities
 */
declare class OlLayerTimeSelectorComponent implements OnInit {
    protected wmsCaps: WmsCapabilitiesService;
    readonly layer: i0.InputSignal<BaseLayer>;
    currentTime: Date | undefined;
    timeDimensions: Date[] | undefined;
    loading: boolean | undefined;
    protected layerSource: TileWMS | undefined;
    protected layerid: string | undefined;
    protected url: string | undefined;
    ngOnInit(): void;
    onSelect(time: Date): void;
    compareFn(option1: Date, option2: Date): boolean;
    protected determineCurrentTimeParameter(): void;
    protected setTime(time: Date): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerTimeSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerTimeSelectorComponent, "n52-ol-layer-time-selector", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Legend component to animate time dependend layers, the time information is gathered by the WMS capabilities
 */
declare class OlLayerAnimateTimeComponent extends OlLayerTimeSelectorComponent implements OnInit {
    /**
     * Interval of the animation
     */
    readonly timeInterval: i0.InputSignal<number>;
    private interval;
    startAnimation(): void;
    stopAnimation(): void;
    resetAnimation(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerAnimateTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerAnimateTimeComponent, "n52-ol-layer-animate-time", never, { "timeInterval": { "alias": "timeInterval"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Service which holds all generated maps and their ids
 */
declare class OlMapService {
    private map;
    /**
     * Saves id and corresponding map
     *
     * @param mapId
     * @param map
     */
    setMap(mapId: string, map: Map): void;
    /**
     * Delivers the corresponding map as observable to the id
     *
     * @param mapId
     * @returns the map as observable
     */
    getMap(mapId: string): Observable<Map>;
    /**
     * Removes the map to the given map id
     *
     * @param id
     */
    removeMap(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlMapService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OlMapService>;
}

/**
 * Service to hold the corresponding map id
 */
declare class OlMapId {
    private id;
    private subject;
    /**
     * Returns the map id in an observable
     *
     * @returns Observable of the map id
     */
    getId(): Observable<string>;
    /**
     * Sets the map id
     *
     * @param id the map id
     */
    setId(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlMapId, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OlMapId>;
}

/**
 * Defines an abstract class, which must be implemented by every additional component
 */
declare abstract class OlBaseComponent implements AfterViewInit {
    protected mapService: OlMapService;
    protected mapidService: OlMapId;
    /**
     * Subscribes for the initialization of the map after view is initialized
     */
    ngAfterViewInit(): void;
    /**
     * This method will be triggered, when the corrsponding map is initialized.
     * @abstract
     * @param {Map} map - the created map
     */
    abstract mapInitialized(map: Map$1): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OlBaseComponent, never, never, {}, {}, never, never, true, never>;
}

/**
 * Component to configure an additional layer to the map. The component must be embedded as seen in the example
 *
 * @example
 * <n52-ol-map>
 *     <n52-ol-layer></n52-ol-layer>
 * </n52-ol-map>
 */
declare class OlLayerComponent extends OlBaseComponent implements AfterViewInit, OnChanges {
    /**
     * Configured layer
     */
    readonly layer: i0.InputSignal<BaseLayer>;
    private map;
    ngOnChanges(changes: SimpleChanges): void;
    mapInitialized(map: Map): void;
    private addLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerComponent, "n52-ol-layer", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Legend component to ascertain the legend url, gathered by the WMS capabilities
 */
declare class OlLayerLegendUrlComponent {
    private wmsCaps;
    readonly layer: i0.InputSignal<Layer>;
    /**
     * Returns the legend url
     */
    readonly legendUrl: i0.OutputEmitterRef<string>;
    deliverLegendUrl(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerLegendUrlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerLegendUrlComponent, "n52-ol-layer-legend-url", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, { "legendUrl": "legendUrl"; }, never, never, true, never>;
}

/**
 * Legend component handle the opacity of the layer
 */
declare class OlLayerOpacitiySliderComponent implements OnInit, DoCheck {
    readonly layer: i0.InputSignal<BaseLayer>;
    opacity: number | undefined;
    constructor();
    ngOnInit(): void;
    ngDoCheck(): void;
    setOpacity(o: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerOpacitiySliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerOpacitiySliderComponent, "n52-ol-layer-opacitiy-slider", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Legend component to display the title, gathered by the WMS capabilities
 */
declare class OlLayerTitleComponent implements OnInit {
    private wmsCaps;
    readonly layer: i0.InputSignal<Layer>;
    title: string | undefined;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerTitleComponent, "n52-ol-layer-title", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Legend component to toggle the visibility
 */
declare class OlLayerVisibilityTogglerComponent {
    readonly layer: i0.InputSignal<BaseLayer>;
    toggleVisibility(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerVisibilityTogglerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerVisibilityTogglerComponent, "n52-ol-layer-visibility-toggler", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Legend component to gather the layer extent by the WMS capabilities and provide the ability to zoom to the extent
 */
declare class OlLayerZoomExtentComponent implements OnInit {
    private wmsCaps;
    private mapServices;
    readonly layer: i0.InputSignal<BaseLayer>;
    /**
     * corresponding map id
     */
    readonly mapId: i0.InputSignal<string>;
    private extent;
    private crs;
    private view;
    ngOnInit(): void;
    zoomToExtent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlLayerZoomExtentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlLayerZoomExtentComponent, "n52-ol-layer-zoom-extent", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; "mapId": { "alias": "mapId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Basic open layers map component, which creates a map with an OSM layer as first base layer.
 */
declare class OlMapComponent implements AfterViewInit {
    private mapService;
    private mapid;
    /**
     * The map id, to reference this map outside of this component. If no id is given, a unique one is generated
     */
    readonly mapId: i0.InputSignal<string>;
    /**
     * Longitude to center the map
     */
    readonly lon: i0.InputSignal<number>;
    /**
     * Latitude to center the map
     */
    readonly lat: i0.InputSignal<number>;
    /**
     * Zoom level of the map
     */
    readonly zoom: i0.InputSignal<number>;
    /**
     * Projection of the map
     */
    readonly projection: i0.InputSignal<string>;
    /**
     * Should the zoom controls be visible on the map
     */
    readonly showZoomControl: i0.InputSignal<boolean>;
    /**
     * Should the attribution label be visible on the map
     */
    readonly showAttributionControl: i0.InputSignal<boolean>;
    private map;
    ngAfterViewInit(): void;
    private generateUUID;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlMapComponent, "n52-ol-map", never, { "mapId": { "alias": "mapId"; "required": true; "isSignal": true; }; "lon": { "alias": "lon"; "required": false; "isSignal": true; }; "lat": { "alias": "lat"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "projection": { "alias": "projection"; "required": false; "isSignal": true; }; "showZoomControl": { "alias": "showZoomControl"; "required": false; "isSignal": true; }; "showAttributionControl": { "alias": "showAttributionControl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Control component to show the coordinates at the mouse position
 */
declare class OlMousePositionComponent extends OlBaseComponent {
    private elementRef;
    readonly projection: i0.InputSignal<string>;
    mapInitialized(map: Map): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlMousePositionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlMousePositionComponent, "n52-ol-mouse-position", never, { "projection": { "alias": "projection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Control component for an overview map
 */
declare class OlOverviewMapComponent extends OlBaseComponent {
    /**
     * Collapsed on startup
     */
    readonly collased: i0.InputSignal<boolean>;
    /**
     * Can be collapsed
     */
    readonly collapsible: i0.InputSignal<boolean>;
    /**
     * Layers, which are shown in the overview map
     */
    readonly layers: i0.InputSignal<Layer[]>;
    /**
     * position of the overview map
     */
    readonly position: i0.InputSignal<"upperleft" | "upperright" | "bottomleft" | "bottomright">;
    mapInitialized(map: Map): void;
    private createLabel;
    private createCollapseLabel;
    generateClassName(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlOverviewMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlOverviewMapComponent, "n52-ol-overview-map", never, { "collased": { "alias": "collased"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "layers": { "alias": "layers"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Component to display station based on the input parameters. The component must be embedded as seen in the example:
 *
 * @example
 * <n52-ol-map>
 *     <n52-ol-station-selector-layer [serviceUrl]="serviceUrl" [filter]="filter"></n52-ol-station-selector-layer>
 * </n52-ol-map>
 */
declare class OlStationSelectorLayerComponent extends OlBaseComponent {
    protected servicesConnector: HelgolandServicesConnector;
    /**
     * The serviceUrl, where the selection should be loaded.
     */
    readonly serviceUrl: i0.InputSignal<string>;
    /**
     * The filter which should be used, while fetching the selection.
     */
    readonly filter: i0.InputSignal<HelgolandParameterFilter | undefined>;
    /**
     * Zoom to the stations after collected and displayed
     */
    readonly zoomToResult: i0.InputSignal<boolean>;
    /**
     * Cluster stations
     */
    readonly cluster: i0.InputSignal<boolean>;
    /**
     * Inform, when a station is selected
     */
    readonly onSelected: i0.OutputEmitterRef<HelgolandPlatform>;
    /**
     * Inform, while stations are loaded
     */
    readonly onContentLoading: i0.OutputEmitterRef<boolean>;
    /**
     * Inform, when no stations are found
     */
    readonly onNoResultsFound: i0.OutputEmitterRef<boolean>;
    private map;
    private layer;
    mapInitialized(map: Map): void;
    private drawGeometries;
    private createStationGeometries;
    private createLayer;
    private createFeatureList;
    private createHoverInteraction;
    private createClickInteraction;
    private styleClusterLayer;
    private createClusterStyle;
    private zoomToFeatures;
    private createMarkerStyle;
    static ɵfac: i0.ɵɵFactoryDeclaration<OlStationSelectorLayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OlStationSelectorLayerComponent, "n52-ol-station-selector-layer", never, { "serviceUrl": { "alias": "serviceUrl"; "required": true; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "zoomToResult": { "alias": "zoomToResult"; "required": false; "isSignal": true; }; "cluster": { "alias": "cluster"; "required": false; "isSignal": true; }; }, { "onSelected": "onSelected"; "onContentLoading": "onContentLoading"; "onNoResultsFound": "onNoResultsFound"; }, never, never, true, never>;
}

/**
 * The open layers module includes the following functionality:
 * - open-layers map component and different control components
 */
declare class HelgolandOpenLayersModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HelgolandOpenLayersModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HelgolandOpenLayersModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.HelgolandCoreModule, typeof OlLayerAbstractComponent, typeof OlLayerAnimateTimeComponent, typeof OlLayerComponent, typeof OlLayerLegendUrlComponent, typeof OlLayerOpacitiySliderComponent, typeof OlLayerTimeSelectorComponent, typeof OlLayerTitleComponent, typeof OlLayerVisibilityTogglerComponent, typeof OlLayerZoomExtentComponent, typeof OlMapComponent, typeof OlMousePositionComponent, typeof OlOverviewMapComponent, typeof OlStationSelectorLayerComponent], [typeof OlLayerAbstractComponent, typeof OlLayerAnimateTimeComponent, typeof OlLayerComponent, typeof OlLayerLegendUrlComponent, typeof OlLayerOpacitiySliderComponent, typeof OlLayerTimeSelectorComponent, typeof OlLayerTitleComponent, typeof OlLayerVisibilityTogglerComponent, typeof OlLayerZoomExtentComponent, typeof OlMapComponent, typeof OlMousePositionComponent, typeof OlOverviewMapComponent, typeof OlStationSelectorLayerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HelgolandOpenLayersModule>;
}

export { HelgolandOpenLayersModule, OlBaseComponent, OlLayerAbstractComponent, OlLayerAnimateTimeComponent, OlLayerComponent, OlLayerLegendUrlComponent, OlLayerOpacitiySliderComponent, OlLayerTimeSelectorComponent, OlLayerTitleComponent, OlLayerVisibilityTogglerComponent, OlLayerZoomExtentComponent, OlMapComponent, OlMapId, OlMapService, OlMousePositionComponent, OlOverviewMapComponent, OlStationSelectorLayerComponent, WmsCapabilitiesService };
export type { WMSLayer };