import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
import * as i0 from '@angular/core';
import { Signal } from '@angular/core';
import { Subject, Observable } from 'rxjs';
import { CollectionEvent } from 'ol/Collection';
import { EventsKey } from 'ol/events';
import { Layer, Vector } from 'ol/layer';
import { Source, Cluster, Vector as Vector$1 } from 'ol/source';
import { HsUrlWmsService, HsAddDataOwsService } from 'hslayers-ng/services/add-data';
import { HsConfig } from 'hslayers-ng/config';
import { HsWmtsGetCapabilitiesService, HsWfsGetCapabilitiesService, HsWmsGetCapabilitiesService, HsDimensionTimeService } from 'hslayers-ng/services/get-capabilities';
import { HsEventBusService } from 'hslayers-ng/services/event-bus';
import { HsLanguageService } from 'hslayers-ng/services/language';
import { HsLayerDescriptor, HsWmsLayer, MetadataUrl, WMSGetCapabilitiesResponse, HsLayermanagerFolder, HsTerrainLayerDescriptor } from 'hslayers-ng/types';
import { HsLayoutService } from 'hslayers-ng/services/layout';
import { HsLogService } from 'hslayers-ng/services/log';
import { HsMapService } from 'hslayers-ng/services/map';
import { HsQueuesService } from 'hslayers-ng/services/queues';
import { HsToastService } from 'hslayers-ng/common/toast';
import * as ol_geom from 'ol/geom';
import { Feature } from 'ol';
import { HsStylerService } from 'hslayers-ng/services/styler';

declare class HsLayerSelectorService {
    currentLayer: HsLayerDescriptor;
    layerSelected: Subject<HsLayerDescriptor>;
    constructor();
    /**
     * Multi-casts new HsLayerManagerService.currentLayer to observers listening to the layerSelected subject.
     * @param hsLayer - Selected layer (HsLayerManagerService.currentLayer)
     */
    select(hsLayer: HsLayerDescriptor): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerSelectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerSelectorService>;
}

declare class HsLayerEditorVectorLayerService {
    hsConfig: HsConfig;
    hsMapService: HsMapService;
    hsStylerService: HsStylerService;
    layersClusteredFromStart: any[];
    /**
     * Convert layer to clustered state where its source gets nested in another
     * VectorSource and first level sources features contain 'features' attribute
     * with the original features in it as an array
     * @param newValue - Cluster or not to cluster
     * @param layer - OL Layer to cluster or de-cluster
     * @param distance - Minimum distance in pixels between clusters
     * @param generateStyle - Whether a default cluster style shall be generated for the layer
     */
    cluster(newValue: boolean, layer: Layer<Source>, distance: number, generateStyle: boolean): Promise<void>;
    createClusteredSource(layer: Layer<Source>, distance: number): Cluster<Feature<ol_geom.Geometry>>;
    updateFeatureTableLayers(layer: Vector<Vector$1<Feature>>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorVectorLayerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerEditorVectorLayerService>;
}

declare class HsLayerManagerMetadataService {
    hsWmtsGetCapabilitiesService: HsWmtsGetCapabilitiesService;
    hsWfsGetCapabilitiesService: HsWfsGetCapabilitiesService;
    hsWmsGetCapabilitiesService: HsWmsGetCapabilitiesService;
    private hsArcgisGetCapabilitiesService;
    hsDimensionTimeService: HsDimensionTimeService;
    hsLog: HsLogService;
    hsUrlWmsService: HsUrlWmsService;
    private hsMapService;
    private hsAddDataUrlService;
    private hsCommonLaymanService;
    private hsCommonLaymanLayerService;
    /**
     * Recursive callback which identifies object representing added layer in WMS getCapabilities structure.
     * It is used as reference for sublayer structure, metadata
     * @returns Wms layer definition
     */
    identifyLayerObject(layerName: string, currentLayer: HsWmsLayer, serviceLayer?: boolean): HsWmsLayer;
    getParsedLayers(layerObject: any): any;
    /**
     * Adds hasSublayers parameter if layer has sub-layers
     * @param layerDescriptor - Selected layer
     */
    fillMetadata(layerDescriptor: HsLayerDescriptor): Promise<void>;
    metadataArray(layer: HsLayerDescriptor): Array<MetadataUrl>;
    /**
     * Determines if layer has metadata information available
     * @param layer - Current layer
     */
    hasMetadata(layer: HsLayerDescriptor): boolean;
    /**
     * Looks for maxScaleDenominator in property object
     */
    searchForScaleDenominator(properties: any): number;
    /**
     * Sets or updates values in layer object
     */
    setOrUpdate(layer: Layer<Source>, key: any, values: any): void;
    private parseWmsCapsMultipleLayers;
    private parseWmsCapsSingleLayer;
    /**
     * Parse capabilities for WMS layer
     */
    parseWmsCaps(layerDescriptor: HsLayerDescriptor, layerName: string, caps: WMSGetCapabilitiesResponse): void;
    private setExtentAndOriginalExtent;
    /**
     * Set layer extent using capabilities layer object
     */
    private setWmsCapsExtent;
    /**
     * Helper used in to get usable extent from layers capabilities object
     */
    private getCapsExtent;
    private collectLegend;
    parseAttribution(layer: Layer<Source>, caps: any): void;
    /**
     * Callback function, adds getCapabilities response metadata to layer object
     * @param layerDescriptor - Selected layer
     * @returns Promise
     */
    queryMetadata(layerDescriptor: HsLayerDescriptor): Promise<boolean>;
    parseArcGisCaps(layerDescriptor: HsLayerDescriptor, resp: any): void;
    identifyArcgisLayerObj(layerId: number, caps: {
        mapName: string;
        layers: {
            id: number;
            name: string;
            parentLayerId?: number;
            defaultVisibility?: boolean;
            subLayerIds?: number[];
            minScale?: number;
            maxScale?: number;
            type?: string;
            geometryType?: string;
        }[];
    }): {
        Title: string;
        Name: number;
        Layer?: {
            Title: string;
            Name: number;
        }[];
    };
    private fillMetadataUrlsIfNotExist;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerMetadataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerMetadataService>;
}

declare class HsLayermanagerDataObject {
    folders: Signal<Map<string, HsLayermanagerFolder>>;
    layers: HsLayerDescriptor[];
    baselayers: HsLayerDescriptor[];
    terrainLayers: HsTerrainLayerDescriptor[];
    baselayer?: string;
    /**
     * Defined from component to allow reactivity
     */
    filter: Observable<string>;
    constructor();
}
declare class HsLayerManagerService {
    hsConfig: HsConfig;
    hsDimensionTimeService: HsDimensionTimeService;
    hsEventBusService: HsEventBusService;
    hsLanguageService: HsLanguageService;
    hsLayerEditorVectorLayerService: HsLayerEditorVectorLayerService;
    hsLayerManagerMetadata: HsLayerManagerMetadataService;
    hsLayerSelectorService: HsLayerSelectorService;
    hsLayoutService: HsLayoutService;
    hsLog: HsLogService;
    hsMapService: HsMapService;
    hsQueuesService: HsQueuesService;
    hsAddDataOwsService: HsAddDataOwsService;
    private hsShareUrlService;
    hsToastService: HsToastService;
    sanitizer: DomSanitizer;
    private hsLayerManagerUtilsService;
    private hsLayerManagerVisibilityService;
    private folderService;
    private hsLoadingProgressService;
    data: HsLayermanagerDataObject;
    timer: any;
    zIndexValue: number;
    mapEventHandlers: EventsKey[];
    constructor();
    /**
     * UnBind event listeners
     */
    destroy(): void;
    /**
     * Setup map-event handlers and store their keys in an array
     */
    private setupMapEventHandlers;
    /**
     * Function for adding layer added to map into layer manager structure.
     * In service automatically used after layer is added to map.
     * Layers which shouldn't be in layer manager (showInLayerManager property) aren't added.
     * Loading events and legends URLs are created for each layer.
     * Layers also get automatic watcher for changing visibility (to synchronize visibility in map and layer manager).
     * Position is calculated for each layer and for time layers time properties are created.
     * Each layer is also inserted in correct layer list and inserted into folder structure.
     * @param e - Event object emitted by OL add layer event
     * @param suspendEvents - If set to true, no new values for layerAdditions, layerManagerUpdates or compositionEdits observables will be emitted.
     */
    layerAdded(e: {
        element: Layer<Source>;
    }, suspendEvents?: boolean): Promise<void>;
    /**
     * Sort layers which are added to map and registered
     * in layermanager by Z and notify components that layer positions have changed.
     */
    updateLayerListPositions(): void;
    sortLayersByZ(arr: any[]): any[];
    /**
     * Executed when a content of data.baselayers or data.terrainLayers changes.
     * Angular does not detect changes inside arrays unless triggered from the view.
     * But it does detect changes of class properties.
     * Hence the whole array is copied so an "immutable" change happens and Angular detects that.
     */
    refreshLists(): void;
    /**
     * (PRIVATE) Get layer by its title
     */
    getLayerByTitle(title: string): HsLayerDescriptor | undefined;
    /**
     * Get layer container object for OL layer
     * @param layer - to get layer title
     * @param base - Wether to search within base layers or not. Defaults to false
     * @returns Layer container which is used in layer-list directive
     */
    getLayerDescriptorForOlLayer(layer: Layer<Source>, base?: boolean): HsLayerDescriptor;
    /**
     * Callback function for removing layer. Clean layers variables
     * @param e - Events emitted by ol.Collection instances are instances of this type.
     */
    layerRemoved(e: CollectionEvent<Layer>): void;
    removeFromArray(arrayToSearch: Layer<Source>[], layer: Layer<Source>): void;
    /**
     * Makes layer greyscale
     * @param layer - Selected layer (currentLayer)
     */
    setGreyscale(layer: HsLayerDescriptor): void;
    resolutionChangeDebounceCallback(): void;
    /**
     * Opens editor for layer specified in 'hs-layer-selected' url parameter
     */
    private toggleEditLayerByUrlParam;
    private setPathMaxZIndex;
    /**
     * When adding a base layer from composition (asCallback false), place it below any existing
     * overlay layers: on top of other base layers, or at 0 if none. Shifts overlay layers up if needed.
     */
    private applyBaseLayerZIndexFromComposition;
    /**
     * Sets zIndex of layer being added.
     * @param layer - layer being added
     * @param asCallback - Whether the function is called directly or as a callback of add layer event.
     * No need to run each layer through setPathMaxZIndex on init
     */
    applyZIndex(layer: Layer<Source>, asCallback?: boolean): void;
    makeSafeAndTranslate(group: string, input: string): SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerService>;
}

declare class HsLayerManagerCopyLayerService {
    hsLayerSelectorService: HsLayerSelectorService;
    hsMapService: HsMapService;
    hsAddDataOwsService: HsAddDataOwsService;
    private hsLayerManagerUtilsService;
    /**
      Creates a copy of the currentLayer
     */
    copyLayer(newTitle: string): Promise<void>;
    /**
      Creates a copy of the currentLayer if it is a vector layer
     */
    copyVectorLayer(newTitle: string): void;
    /**
      Creates a new title for the copied layer
     */
    createCopyTitle(newTitle: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerCopyLayerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerCopyLayerService>;
}

declare class HsLayerManagerUtilsService {
    private hsConfig;
    private hsLayerSelectorService;
    private hsMapService;
    private hsLog;
    currentLayer: HsLayerDescriptor;
    layerSelected: Subject<HsLayerDescriptor>;
    /**
     * DEPRECATED?
     */
    expandFilter(layer: HsLayerDescriptor, value: any): void;
    /**
     * DEPRECATED?
     */
    expandInfo(layer: HsLayerDescriptor, value: any): void;
    /**
      Generates downloadable GeoJSON for vector layer.
      Features are also transformed into the EPSG:4326 projection
     */
    saveGeoJson(): void;
    /**
     * Triage of layer source type and format.
     * Only the commonly used values are listed here, it shall be probably extended in the future.
     * @returns Short description of source type: 'WMS', 'XYZ', 'vector (GeoJSON)' etc.
     */
    getLayerSourceType(layer: Layer<Source>): Promise<string>;
    /**
     * Gets the URL provided in the layer's source, if it is not a data blob or undefined
     * @returns URL provided in the layer's source or 'memory'
     */
    getLayerSourceUrl(layer: Layer<Source>): string;
    checkLayerHealth(layer: Layer<Source>): void;
    /**
     * Function for adding baselayer thumbnail visible in basemap gallery.
     * @param layer - Base layer added to map
     */
    getImage(layer: Layer<Source>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerUtilsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerUtilsService>;
}

declare class HsLayerManagerVisibilityService {
    private hsMapService;
    private hsConfig;
    private hsEventBusService;
    /**
     * Store if baselayers are visible (more precisely one of baselayers)
     */
    baselayersVisible: boolean;
    currentResolution: number;
    data: HsLayermanagerDataObject;
    layerVisibilityChanged(e: any): void;
    /**
     * Test if layer (WMS) resolution is within map resolution interval
     * @param lyr - Selected layer
     */
    isLayerInResolutionInterval(lyr: Layer<Source>): boolean;
    /**
     * Change visibility of selected layer. If layer has exclusive setting, other layers from same group may be turned invisible
     * @param visibility - Visibility layer should have
     * @param layer - Selected layer - wrapped layer object (layer.layer expected)
     */
    changeLayerVisibility(visibility: boolean, layer: HsLayerDescriptor): void;
    /**
     * Change visibility (on/off) of baselayers, only one baselayer may be visible
     * @param $event - Info about the event change visibility event, used if visibility of only one layer is changed
     * @param layer - Selected layer - wrapped layer object (layer.layer expected)
     */
    changeTerrainLayerVisibility($event: any, layer: HsTerrainLayerDescriptor): void;
    /**
     * Change visibility (on/off) of baselayers, only one baselayer may be visible
     * @param $event - Info about the event change visibility event, used if visibility of only one layer is changed
     * @param layer - Selected layer - wrapped layer object (layer.layer expected)
     */
    changeBaseLayerVisibility($event?: any, layer?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerVisibilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerVisibilityService>;
}

declare enum FolderActionTypes {
    ADD_LAYER = "ADD_LAYER",
    REMOVE_LAYER = "REMOVE_LAYER",
    SORT_BY_Z = "SORT_BY_Z",
    UPDATE_Z = "UPDATE_Z"
}
interface AddLayerAction {
    type: FolderActionTypes.ADD_LAYER;
    lyr: HsLayerDescriptor;
}
interface RemoveLayerAction {
    type: FolderActionTypes.REMOVE_LAYER;
    lyr: HsLayerDescriptor;
}
interface SortFoldersByZAction {
    type: FolderActionTypes.SORT_BY_Z;
    lyr: HsLayerDescriptor;
    debounce: boolean;
}
interface UpdateFoldersZIndex {
    type: FolderActionTypes.UPDATE_Z;
    lyr: HsLayerDescriptor;
}
type FolderAction = AddLayerAction | RemoveLayerAction | SortFoldersByZAction | UpdateFoldersZIndex;
declare class HsLayerManagerFolderService {
    private hsLanguageService;
    private hsConfig;
    private sortDebounceTime;
    private sortSubject;
    folderAction$: Subject<FolderAction>;
    data: HsLayermanagerDataObject;
    constructor();
    foldersReducer(state: Map<string, HsLayermanagerFolder>, action: FolderAction): Map<string, HsLayermanagerFolder>;
    addLayer(lyr: HsLayerDescriptor): AddLayerAction;
    removeLayer(lyr: HsLayerDescriptor): RemoveLayerAction;
    updateFoldersZIndex(): UpdateFoldersZIndex;
    sortByZ(options?: {
        debounce: boolean;
    }): SortFoldersByZAction;
    /**
     * Place layer into layer manager folder structure based on path property hsl-path of layer
     * @param lyr - Layer to add into folder structure
     */
    private populateFolders;
    /**
     * Remove layer from layer folder and clean empty folder
     * @param lyr - Layer to remove from layer folder
     */
    private cleanFolders;
    /**
     * Update zIndex of folders and sort them
     * @param lyr Layer that has changed.
     */
    private updateFoldersZ;
    /**
     * Sorts folders by z-index.
     */
    private sortFoldersByZ;
    sortLayersByZ(arr: any[]): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerFolderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerFolderService>;
}

declare class HsLayerManagerLoadingProgressService {
    private hsConfig;
    private hsLog;
    private zone;
    private hsToastService;
    private hsLanguageService;
    private hsEventBusService;
    /**
     * Create events for checking whether the layer is being loaded or is loaded
     * @param layer - Layer which is being added
     */
    loadingEvents(layer: HsLayerDescriptor): void;
    private determineLayerType;
    private loadError;
    private featuresLoadFailed;
    private imageLoadFailed;
    private tileLoadFailed;
    /**
     * Creates loading progress timer which controls the executions of load events callbacks
     * and tries to reset progress once the loading has finished (no execution in 2000ms)
     */
    private createLoadingProgressTimer;
    /**
     * Create an event subject which is used to cast value in an event callback.
     * and
     * Subscribe to an subject to allow debouncing of event callback method.
     * Subscription increments or decrements pending parameter of loadProgress which is used to indicate progress in UI
     */
    private subscribeToEventSubject;
    /**
     * Adjust layer progress counter object and calculate loading state (percentages)
     * change is positive number in case of loadStart and negative number in case of loadEnd/Error events
     */
    private changeLoadCounter;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerLoadingProgressService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerManagerLoadingProgressService>;
}

export { HsLayerEditorVectorLayerService, HsLayerManagerCopyLayerService, HsLayerManagerFolderService, HsLayerManagerLoadingProgressService, HsLayerManagerMetadataService, HsLayerManagerService, HsLayerManagerUtilsService, HsLayerManagerVisibilityService, HsLayerSelectorService, HsLayermanagerDataObject };