import * as i0 from '@angular/core';
import { OnInit, ViewRef, DestroyRef, ComponentRef, ViewContainerRef, AfterViewInit, ElementRef, WritableSignal, Signal } from '@angular/core';
import { HsDimensionDescriptor } from 'hslayers-ng/common/dimensions';
import { HsDimensionService, HsDimensionTimeService } from 'hslayers-ng/services/get-capabilities';
import { HsEventBusService } from 'hslayers-ng/services/event-bus';
import { BehaviorSubject, Subject, Observable } from 'rxjs';
import * as ol_layer from 'ol/layer';
import { Layer } from 'ol/layer';
import * as hslayers_ng_types from 'hslayers-ng/types';
import { HsLayerDescriptor, HsSublayer, HsWmsLayer, HsLayermanagerFolder, HsTerrainLayerDescriptor } from 'hslayers-ng/types';
export * from 'hslayers-ng/types';
import { HsLayerSelectorService, HsLayerManagerService, HsLayerManagerVisibilityService, HsLayerManagerMetadataService, HsLayerManagerFolderService } from 'hslayers-ng/services/layer-manager';
import * as i20 from 'hslayers-ng/common/panels';
import { HsPanelComponent, HsGuiOverlayBaseComponent, HsPanelBaseComponent } from 'hslayers-ng/common/panels';
import { HsMapService } from 'hslayers-ng/services/map';
import { HsConfig } from 'hslayers-ng/config';
import { HsLayoutService } from 'hslayers-ng/services/layout';
import * as ol_renderer_Layer from 'ol/renderer/Layer';
import * as ol_source from 'ol/source';
import { Source } from 'ol/source';
import { getBase, getGreyscale, getActive, getTitle, getThumbnail, getAttribution } from 'hslayers-ng/common/extensions';
import { HsPanelContainerService } from 'hslayers-ng/services/panels';
import * as i21 from 'hslayers-ng/components/legend';
import { HsLegendDescriptor } from 'hslayers-ng/components/legend';
import * as i22 from '@ng-bootstrap/ng-bootstrap';
import { NgbDropdown } from '@ng-bootstrap/ng-bootstrap';
import * as i23 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { HsDialogContainerService, HsDialogComponent, HsDialogItem } from 'hslayers-ng/common/dialogs';
import { HslayersService } from 'hslayers-ng/core';
import { HsCompositionsParserService } from 'hslayers-ng/services/compositions';
import { HsDrawService } from 'hslayers-ng/services/draw';
import { HsLanguageService } from 'hslayers-ng/services/language';
import { Feature } from 'ol';
import { InterpolatedSource } from 'hslayers-ng/common/layers';
import * as i17 from '@ngx-translate/core';
import * as i18 from '@angular/common';
import * as i19 from '@angular/forms';
import * as i24 from 'hslayers-ng/common/color-map-picker';
import * as i27 from 'hslayers-ng/common/pipes';
import * as i28 from 'hslayers-ng/common/clipboard-text';

declare class HsLayerEditorWidgetBaseComponent implements HsPanelComponent, OnInit {
    hsLayerSelectorService: HsLayerSelectorService;
    /**
     * This could be used to enable/disable widgets by name on HsConfig level
     */
    name: string;
    viewRef: ViewRef;
    data: any;
    layerDescriptor: BehaviorSubject<HsLayerDescriptor>;
    olLayer: Layer;
    isVisible$: BehaviorSubject<boolean>;
    baseComponentInitRun: boolean;
    destroyRef: DestroyRef;
    constructor();
    ngOnInit(): void;
    isVisible(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorWidgetBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerEditorWidgetBaseComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class HsLayerEditorDimensionsComponent extends HsLayerEditorWidgetBaseComponent implements OnInit {
    hsDimensionService: HsDimensionService;
    hsDimensionTimeService: HsDimensionTimeService;
    hsMapService: HsMapService;
    hsEventBusService: HsEventBusService;
    name: string;
    dimensions: Array<HsDimensionDescriptor>;
    constructor();
    updateDimensions(): void;
    dimensionIsTime(dimension: HsDimensionDescriptor): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorDimensionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerEditorDimensionsComponent, "hs-layer-editor-dimensions", never, {}, {}, never, never, false, never>;
}

declare class HsLayerManagerTimeEditorComponent implements OnInit {
    hsEventBusService: HsEventBusService;
    hsDimensionTimeService: HsDimensionTimeService;
    hsLayoutService: HsLayoutService;
    hsConfig: HsConfig;
    layer: HsLayerDescriptor;
    availableTimes: Array<string>;
    availableTimesFetched: boolean;
    /**
     * ISO format time
     */
    currentTime: string;
    currentTimeIdx: number;
    hasPreviousTime: boolean;
    hasFollowingTime: boolean;
    selectElement: any;
    selectVisible: boolean;
    timeDisplayFormat: string;
    timesInSync: boolean;
    constructor();
    ngOnInit(): void;
    /**
     * Sets hasPreviousTime and hasFollowingTime properties
     */
    checkPrevFollowTimesAvailability(): boolean;
    /**
     * Handler for the "prev" button click
     */
    previousTime(): void;
    /**
     * Handler for the "next" button click
     */
    followingTime(): void;
    /**
     * Handler for a time selection from the SELECT element
     */
    selectTime(): void;
    setCurrentTimeIfAvailable(time: string): void;
    /**
     * Set selected 'time' on the layer object
     */
    setLayerTime(): void;
    showTimeSelect(): void;
    hideTimeSelect(): void;
    synchronizeTimes(): void;
    /**
     * This gets called from subscriber and also OnInit because
     * subscriber could have been set up after the event was broadcasted
     */
    private fillAvailableTimes;
    private setDateTimeFormatting;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerTimeEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerManagerTimeEditorComponent, "hs-layer-manager-time-editor", never, { "layer": { "alias": "layer"; "required": false; }; }, {}, never, never, true, never>;
}

declare class HsLayerEditorWidgetContainerService extends HsPanelContainerService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorWidgetContainerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerEditorWidgetContainerService>;
}

declare class HsLayerEditorComponent {
    private hsConfig;
    private hsStylerService;
    private hsLayoutService;
    private hsLayerEditorService;
    private hsEventBusService;
    private hsDialogContainerService;
    private hsLayerManagerUtilsService;
    private hsLayerManagerCopyLayerService;
    hsLayerManagerService: HsLayerManagerService;
    hsWidgetContainerService: HsLayerEditorWidgetContainerService;
    layer: i0.InputSignal<HsLayerDescriptor>;
    olLayer: i0.Signal<ol_layer.Layer<ol_source.Source, ol_renderer_Layer.default<any>>>;
    layerNodeAvailable: i0.WritableSignal<boolean>;
    layer_renamer_visible: i0.WritableSignal<boolean>;
    layerTitle: i0.ModelSignal<string>;
    getBase: typeof getBase;
    getGreyscale: typeof getGreyscale;
    layerIsZoomable: i0.Signal<boolean>;
    layerIsStylable: i0.Signal<boolean>;
    isLayerRemovable: i0.Signal<boolean>;
    isVectorLayer: i0.Signal<boolean>;
    wfsFilterEnabled: i0.Signal<string>;
    titleUnsaved: i0.Signal<boolean>;
    constructor();
    createWidgets(): Promise<void>;
    /**
     * Confirm saving a vector layer content as a GeoJSON
     * @returns an empty promise
     */
    createSaveDialog(): Promise<void>;
    /**
     * Zoom to selected layer (layer extent). Get extent
     * from bounding box property, getExtent() function or from
     * BoundingBox property of GetCapabilities request (for WMS layer)
     * @returns a promise
     */
    zoomToLayer(): Promise<any>;
    /**
     * Display styler panel for selected layer, so user can change its style
     */
    styleLayer(): void;
    /**
     * Toggle layer rename control on panel (through layer rename variable)
     */
    toggleLayerRename(): void;
    removeLayer(): void;
    /**
     * Save the layer title
     */
    saveTitle(): void;
    copyLayer(): Promise<void>;
    /**
     * Open the WFS filter panel
     * layer will be automatically selected via hsLayerSelectorService
     */
    openWfsFilter(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerEditorComponent, "hs-layer-editor", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; "layerTitle": { "alias": "layerTitle"; "required": false; "isSignal": true; }; }, { "layerTitle": "layerTitleChange"; }, never, never, true, never>;
}

declare class HsLayerEditorSublayersComponent {
    private hsLayerEditorSublayerService;
    layer: i0.InputSignal<HsLayerDescriptor>;
    subLayers: i0.Signal<hslayers_ng_types.HsSublayer[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorSublayersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerEditorSublayersComponent, "hs-layer-editor-sublayers", never, { "layer": { "alias": "layer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HsLayerEditorService {
    private hsMapService;
    private hsWmsGetCapabilitiesService;
    private hsLayerEditorVectorLayerService;
    private hsEventBusService;
    private hsLayoutService;
    private hsLegendService;
    private hsLayerSelectorService;
    private hsLayerManagerMetadataService;
    private hsLayerEditorSublayerService;
    private hsShareUrlService;
    legendDescriptor: HsLegendDescriptor;
    layerTitleChange: Subject<{
        newTitle: string;
        oldTitle: string;
        layer: Layer<Source>;
    }>;
    editorComponent: ComponentRef<HsLayerEditorComponent>;
    sublayerEditorComponent: ComponentRef<HsLayerEditorSublayersComponent>;
    constructor();
    /**
     * Create layer editor component for settings
     * @param vcr - View container reference
     * @param layer - Layer
     */
    createLayerEditor(vcr: ViewContainerRef, layer: HsLayerDescriptor): ComponentRef<HsLayerEditorComponent> | undefined;
    /**
     * Create layer editor component for sublayers
     * @param vcr - View container reference
     * @param layer - Layer
     */
    createSublayerEditor(vcr: ViewContainerRef, layer: HsLayerDescriptor): ComponentRef<HsLayerEditorSublayersComponent> | undefined;
    /**
     * Generic method to create an editor component
     * @param vcr - View container reference
     * @param layer - Layer
     * @param type - Type of editor ('settings' or 'sublayers')
     * @param componentType - Component type to create
     */
    private createEditor;
    /**
     * Toggles layer editor for current layer.
     * @param layer - Selected layer
     * @param toToggle - Part of layer editor to be toggled ('sublayers' or 'settings')
     * @returns Boolean indicating whether the editor should be created
     */
    toggleLayerEditor(layer: HsLayerDescriptor, toToggle: 'sublayers' | 'settings'): boolean;
    /**
     * Updates the current layer and its title in the URL
     * @param layer - The layer to set as current or undefined to remove the current layer
     */
    setCurrentLayer(layer: HsLayerDescriptor | undefined): void;
    private updateGetParam;
    /**
     * Zoom to selected layer (layer extent). Get extent
     * from bounding box property, getExtent() function or from
     * BoundingBox property of GetCapabilities request (for WMS layer)
     * @param layer - OpenLayers layer to zoom to
     */
    zoomToLayer(layer: Layer<Source>): Promise<boolean>;
    /**
     * Set cluster for layer
     * @param layer - Layer
     * @param newValue - To cluster or not to cluster
     * @param distance - Distance in pixels
     * @returns Current cluster state
     */
    cluster(layer: Layer<Source>, newValue: boolean, distance: number): boolean;
    /**
     * @typedef {Array<number>} Extent
     * @param {Extent} extent - Extent in EPSG:4326
     */
    fitIfExtentSet(extent: number[], layer: Layer<Source>): void;
    transformToCurrentProj(extent: number[]): number[];
    legendVisible(): boolean;
    /**
     * Test if layer is Vector layer
     * @param layer - Selected layer
     */
    isLayerVectorLayer(layer: Layer<Source>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerEditorService>;
}

declare class HsLayerEditorSubLayerCheckboxesComponent implements OnInit {
    private hsLayerEditorSublayerService;
    hsLayerManagerVisibilityService: HsLayerManagerVisibilityService;
    private hsConfig;
    parent: i0.InputSignal<HsSublayer>;
    subLayer: i0.InputSignal<HsSublayer>;
    getNestedLayers: i0.Signal<HsSublayer[]>;
    app: string;
    expanded: boolean;
    ngOnInit(): void;
    subLayerIsString(subLayer: any): boolean;
    toggleExpanded(): void;
    /**
     * Controls state of layer´s sublayers manipulated by input checkboxes
     * @param sublayer - Selected sublayer
     * @param state - New state of sublayer
     */
    subLayerSelected(sublayer: HsSublayer, parent?: HsSublayer): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorSubLayerCheckboxesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerEditorSubLayerCheckboxesComponent, "hs-layer-editor-sub-layer-checkbox", never, { "parent": { "alias": "parent"; "required": false; "isSignal": true; }; "subLayer": { "alias": "subLayer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HsLayerEditorSublayerService {
    private hsLayerManagerVisibilityService;
    layer: HsLayerDescriptor;
    populatedLayers: Array<any>;
    sublayers: HsSublayer[];
    getSubLayers(layer: HsLayerDescriptor): HsSublayer[];
    /**
     * Converts HsWmsLayer to HsSublayer
     */
    mapWMSToLayerVisibility(layers: HsWmsLayer[], visible: boolean): HsSublayer[];
    /**
     * Populates the sublayers of a layer with the given layer descriptor.
     */
    populateSubLayers(lyr: HsLayerDescriptor): HsSublayer[];
    /**
     * Constructs LAYERS param for layer visibility
     */
    constructLayersParam(layers: HsSublayer[]): string;
    /**
     * Handles the selection of a sublayer, updating the layer's visibility and parameters.
     */
    subLayerSelected(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerEditorSublayerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerEditorSublayerService>;
}

declare class HsLayerListService {
    hsLayerManagerService: HsLayerManagerService;
    hsLayerEditorSublayerService: HsLayerEditorSublayerService;
    /**
     * Controls state of layer's sublayers checkboxes with layer visibility changes
     * @param layer - Selected layer
     */
    toggleSublayersVisibility(layer: HsLayerDescriptor): void;
    /**
     * Recursively updates the visibility of sublayers and stores their previous visibility state
     * @param sublayers - Array of sublayers to update
     * @param visible - The new visibility state to set
     */
    private updateSublayersVisibility;
    /**
     * Recursively restores the visibility of sublayers based on their previous visibility state
     * @param sublayers - Array of sublayers to restore
     */
    private restoreSublayersVisibility;
    /**
     * Test if layer is queryable (WMS layer with Info format)
     * @param layer_container - Selected layer - wrapped in layer object
     * @returns Boolean indicating if the layer is queryable
     */
    isLayerQueryable(layer_container: HsLayerDescriptor): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerListService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLayerListService>;
}

declare class HsLayerManagerGalleryComponent extends HsGuiOverlayBaseComponent {
    hsLayerManagerService: HsLayerManagerService;
    private hsLayerSelectorService;
    hsLayerManagerVisibilityService: HsLayerManagerVisibilityService;
    dropdown: NgbDropdown;
    name: string;
    private hsDialogContainerService;
    toggleBasemap(layer?: HsLayerDescriptor): void;
    expandMenu(layer: HsLayerDescriptor): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerGalleryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerManagerGalleryComponent, "hs-layer-manager-gallery", never, {}, {}, never, never, true, never>;
}

declare class HsLayerListComponent {
    hsConfig: HsConfig;
    hsLayerManagerService: HsLayerManagerService;
    folder: string;
    filteredLayers: Observable<HsLayerDescriptor[]>;
    constructor();
    filterLayers(folder: HsLayermanagerFolder, filter: string): HsLayerDescriptor[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerListComponent, "hs-layer-manager-layer-list", never, { "folder": { "alias": "folder"; "required": true; }; }, {}, never, never, true, never>;
}

declare class HsLayerPhysicalListComponent implements OnInit {
    private hsEventBusService;
    private hsLayerShiftingService;
    private cdr;
    layerShiftingAppRef: any;
    constructor();
    ngOnInit(): void;
    drop(event: CdkDragDrop<any[]>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerPhysicalListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerPhysicalListComponent, "hs-layermanager-physical-layer-list", never, {}, {}, never, never, false, never>;
}

declare class HsLayerManagerComponent extends HsPanelBaseComponent implements OnInit, AfterViewInit {
    hsCore: HslayersService;
    hsLayerManagerService: HsLayerManagerService;
    hsEventBusService: HsEventBusService;
    hsDialogContainerService: HsDialogContainerService;
    hsConfig: HsConfig;
    hsLayerListService: HsLayerListService;
    private hsRemoveLayerDialogService;
    hsLayerSelectorService: HsLayerSelectorService;
    hsLayerManagerVisibilityService: HsLayerManagerVisibilityService;
    private hsCommonLaymanService;
    filterInput: ElementRef;
    filteredBaselayers$: Observable<HsLayerDescriptor[]>;
    filteredTerrainlayers$: Observable<HsTerrainLayerDescriptor[]>;
    map: any;
    shiftDown: boolean;
    allLayersVisible: boolean;
    composition_id: string;
    layerlistVisible: boolean;
    hovering: boolean;
    physicalLayerListEnabled: i0.WritableSignal<boolean>;
    cesiumActive$: Observable<boolean>;
    icons: string[];
    getActive: typeof getActive;
    getTitle: typeof getTitle;
    getThumbnail: typeof getThumbnail;
    name: string;
    layerTooltipDelay: number;
    constructor();
    /**
     * Used in template to preserve order of data.folders map entries
     */
    keepOrder: (a: any, b: any) => number;
    ngAfterViewInit(): void;
    /**
     * Create observable with error handling for selected layer type
     */
    createFilteredLayerObservable(type: 'baselayers'): Observable<HsLayerDescriptor[]>;
    createFilteredLayerObservable(type: 'terrainLayers'): Observable<HsTerrainLayerDescriptor[]>;
    private handleFilterLayerError;
    /**
     * Return empty layers result as a result of error while filtering
     */
    private emptyResult;
    ngOnInit(): void;
    togglePhysicalLayerList(): void;
    changeBaseLayerVisibility(e?: any, layer?: HsLayerDescriptor): void;
    changeTerrainLayerVisibility(e: any, layer: HsTerrainLayerDescriptor): void;
    changeLayerVisibility(toWhat: boolean, layer: HsLayerDescriptor): void;
    setProp(layer: Layer<Source>, property: any, value: any): void;
    filterLayers(filter: string, type: 'baselayers' | 'terrainLayers'): HsLayerDescriptor[] | HsTerrainLayerDescriptor[];
    toggleVisibilityForAll(): void;
    /**
     * Removes layer from map object
     * @param layer - Layer to remove
     */
    removeLayer(layer: Layer<Source>): void;
    /**
     * Creates remove-layer dialog which allows for single/multiple layer removal
     */
    removeMultipleLayers(): void;
    /**
     * Removes all layers which don't have 'removable' attribute
     * set to false if user confirms the removal. Might reload composition again.
     */
    removeAllLayers(): void;
    /**
     * Determines if layer has copyright information available *
     * @param layer - Selected layer (HsLayerManagerService.currentLayer)
     */
    hasCopyright(layer: HsLayerDescriptor): boolean | undefined;
    /**
     * Test if layer (WMS) resolution is within map resolution interval
     * @param layer - Selected layer
     */
    isLayerInResolutionInterval(layer: Layer<Source>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerManagerComponent, "hs-layer-manager", never, {}, {}, never, never, false, never>;
}

declare class HsLayerManagerRemoveAllDialogComponent implements HsDialogComponent {
    hsLayerManagerService: HsLayerManagerService;
    hsDialogContainerService: HsDialogContainerService;
    hsEventBusService: HsEventBusService;
    hsCompositionsParserService: HsCompositionsParserService;
    private hsMapService;
    data: any;
    viewRef: ViewRef;
    /**
     * Remove all non-base layers that were added to the map by user.
     * Doesn't remove layers added through app config (In case we want it to be 'removable', it can be set to true in the config.)
     */
    removeAllLayers(reloadComposition?: boolean): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerRemoveAllDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerManagerRemoveAllDialogComponent, "hs-layermanager-remove-all-dialog", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsCopyLayerDialogComponent implements HsDialogComponent {
    hsDialogContainerService: HsDialogContainerService;
    dialogItem: HsDialogItem;
    viewRef: ViewRef;
    data: {
        title: string;
        message: string;
        layerTitle: string;
    };
    yes(): void;
    no(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCopyLayerDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsCopyLayerDialogComponent, "hs-copy-layer-dialog", never, {}, {}, never, never, false, never>;
}

declare class HsLayerManagerRemoveLayerDialogComponent implements HsDialogComponent {
    hsDialogContainerService: HsDialogContainerService;
    hsEventBusService: HsEventBusService;
    hsDrawService: HsDrawService;
    hsMapService: HsMapService;
    data: any;
    viewRef: ViewRef;
    removeLayer(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerRemoveLayerDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerManagerRemoveLayerDialogComponent, "hs-layermanager-remove-layer-dialog", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsTypeWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    showCheck: boolean;
    name: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsTypeWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsTypeWidgetComponent, "hs-type-widget", never, {}, {}, never, never, false, never>;
}

declare class HsMetadataWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    hsLanguageService: HsLanguageService;
    metadataService: HsLayerManagerMetadataService;
    hsLayerManagerService: HsLayerManagerService;
    name: string;
    getAttribution: typeof getAttribution;
    /**
     * Determines if layer has copyright information available
     * @param layer - Selected layer (HsLayerManagerService.currentLayer)
     */
    hasCopyright(layer: HsLayerDescriptor): boolean | undefined;
    set abstract(newAbstract: string);
    get abstract(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsMetadataWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsMetadataWidgetComponent, "hs-metadata-widget", never, {}, {}, never, never, false, never>;
}

declare class HsScaleWidgetComponent extends HsLayerEditorWidgetBaseComponent implements OnInit {
    hsMapService: HsMapService;
    hsLanguageService: HsLanguageService;
    name: string;
    scaleEnabled: WritableSignal<boolean>;
    suppressCacheUpdate: boolean;
    ngOnInit(): void;
    toggle(): void;
    private storeLastValidScaleValues;
    private restoreLastValidScaleValues;
    placeholder: string;
    /**
     * Test if selected layer has min or max resolution set
     */
    isScaleVisible(): boolean;
    /**
     * Set min resolution for selected layer
     */
    set minResolution(newValue: number);
    get minResolution(): number;
    /**
     * Set max resolution for selected layer
     */
    set maxResolution(newValue: number);
    get maxResolution(): number;
    resolutionToScale(resolution: any): number;
    minResolutionValid(): boolean;
    maxResolutionValid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsScaleWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsScaleWidgetComponent, "hs-scale-widget", never, {}, {}, never, never, false, never>;
}

declare class HsClusterWidgetComponent extends HsLayerEditorWidgetBaseComponent implements OnInit {
    private hsLayerEditorService;
    private hsConfig;
    name: string;
    distance: {
        value: number;
    };
    ngOnInit(): void;
    /**
     * Set cluster for layer
     * @param newValue - To cluster or not to cluster
     */
    set cluster(newValue: boolean);
    /**
     * @returns Current cluster state
     */
    get cluster(): boolean | undefined;
    /**
     * Set distance between cluster features;
     */
    changeDistance(): void;
    /**
     * Test if layer is WMS layer
     */
    isVectorLayer(): boolean | undefined;
    /**
     * Parse initial cluster distance value
     */
    private setClusteringDistanceFromConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsClusterWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsClusterWidgetComponent, "hs-cluster-widget", never, {}, {}, never, never, false, never>;
}

declare class HsIdwWidgetComponent extends HsLayerEditorWidgetBaseComponent implements OnInit {
    hsLanguageService: HsLanguageService;
    hsConfig: HsConfig;
    weightAttribute: string;
    attributes: string[];
    name: string;
    colorMaps: string[];
    colorMap: string;
    reversed: boolean;
    min: number | string;
    max: number | string;
    ngOnInit(): void;
    /**
     * Sets colorMap variable value if predefined colorMap is used
     */
    fillColorMapValue(): void;
    /**
     * Get possible attributes from first feature which might be used for interpolation.
     * If no features exist, wait for them.
     */
    fillAttributes(): void;
    listNumericAttributes(features: Feature[]): string[];
    getIdwSource(): InterpolatedSource;
    setWeight(): void;
    setBounds(): void;
    setColorMap(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsIdwWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsIdwWidgetComponent, "hs-idw-widget", never, {}, {}, never, never, false, never>;
}

declare class HsLegendWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    hsLayerEditorService: HsLayerEditorService;
    name: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLegendWidgetComponent, "hs-legend-widget", never, {}, {}, never, never, false, never>;
}

declare class HsOpacityWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    private hsEventBusService;
    name: string;
    /**
     * Set selected layer's opacity and emits "compositionchanged"
     */
    set opacity(newValue: number);
    get opacity(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsOpacityWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsOpacityWidgetComponent, "hs-opacity-widget", never, {}, {}, never, never, false, never>;
}

declare class HsExtentWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    name: string;
    ignoreExtent: boolean;
    isEnabled: Observable<boolean>;
    constructor();
    toggleIgnoreExtent(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsExtentWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsExtentWidgetComponent, "hs-extent-widget", never, {}, {}, never, never, false, never>;
}

declare class HsWmsSourceWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    private hsMapService;
    private hsLayerShiftingService;
    private hsDialogContainerService;
    name: string;
    isEnabled: Observable<boolean>;
    options: string[];
    currentType: string;
    constructor();
    private getUrls;
    private getUrl;
    changeLayerType(): Promise<void>;
    /**
     * Clone layer properties and parameters and recreate it as a different type
     * (Tile or Image)
     */
    private recreateLayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsWmsSourceWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsWmsSourceWidgetComponent, "hs-wms-source-widget", never, {}, {}, never, never, true, never>;
}

declare class HsLayerFolderWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    isEnabled: Observable<boolean>;
    hsDialogContainerService: HsDialogContainerService;
    folderService: HsLayerManagerFolderService;
    constructor();
    /**
     * Creates new layer folder dialog
     */
    createDialog(): Promise<void>;
    /**
     * Move layer to the selected folder
     */
    moveLayerToNewFolder(folder: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerFolderWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerFolderWidgetComponent, "hs-layer-folder-widget", never, {}, {}, never, never, true, never>;
}

declare class HsLayerManagerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerManagerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsLayerManagerModule, [typeof HsLayerManagerComponent, typeof HsLayerEditorDimensionsComponent, typeof HsLayerManagerRemoveAllDialogComponent, typeof HsCopyLayerDialogComponent, typeof HsLayerManagerRemoveLayerDialogComponent, typeof HsLayerEditorWidgetBaseComponent, typeof HsLayerPhysicalListComponent, typeof HsTypeWidgetComponent, typeof HsMetadataWidgetComponent, typeof HsScaleWidgetComponent, typeof HsClusterWidgetComponent, typeof HsIdwWidgetComponent, typeof HsLegendWidgetComponent, typeof HsOpacityWidgetComponent, typeof HsExtentWidgetComponent], [typeof HsLayerListComponent, typeof i17.TranslatePipe, typeof i18.CommonModule, typeof i19.FormsModule, typeof i20.HsPanelHelpersModule, typeof i21.HsLegendModule, typeof i22.NgbDatepickerModule, typeof i22.NgbDropdownModule, typeof i22.NgbTooltipModule, typeof i22.NgbProgressbarModule, typeof i23.DragDropModule, typeof i24.HsColormapPickerModule, typeof HsWmsSourceWidgetComponent, typeof HsLayerFolderWidgetComponent, typeof i20.HsPanelHeaderComponent, typeof i27.FilterPipe, typeof i28.HsClipboardTextComponent], [typeof HsLayerManagerComponent, typeof HsLayerEditorDimensionsComponent, typeof HsLayerListComponent, typeof HsLayerManagerRemoveAllDialogComponent, typeof HsCopyLayerDialogComponent, typeof HsLayerManagerRemoveLayerDialogComponent, typeof HsLayerPhysicalListComponent, typeof HsTypeWidgetComponent, typeof HsMetadataWidgetComponent, typeof HsScaleWidgetComponent, typeof HsClusterWidgetComponent, typeof HsLegendWidgetComponent, typeof HsOpacityWidgetComponent, typeof HsIdwWidgetComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsLayerManagerModule>;
}

type layerType = 'base' | 'thematic';
declare class HsLayerTypeSwitcherWidgetComponent extends HsLayerEditorWidgetBaseComponent {
    private hsLayermanagerService;
    private hsLayerManagerVisibilityService;
    private loadingProgressSerice;
    private folderService;
    private hsEventBusService;
    private hsDialogContainerService;
    private layerEditorService;
    isEnabled: Observable<boolean>;
    currentType: Signal<string>;
    types: layerType[];
    typeChanged$: Observable<void>;
    constructor();
    /***
     * Toggle between base and thematic layer type
     */
    changeLayerType(type: layerType): Promise<void>;
    private updateLayerType;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLayerTypeSwitcherWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLayerTypeSwitcherWidgetComponent, "hs-layer-type-switcher-widget", never, {}, {}, never, never, true, never>;
}

export { HsClusterWidgetComponent, HsCopyLayerDialogComponent, HsIdwWidgetComponent, HsLayerEditorComponent, HsLayerEditorDimensionsComponent, HsLayerEditorService, HsLayerEditorSubLayerCheckboxesComponent, HsLayerEditorSublayerService, HsLayerEditorWidgetBaseComponent, HsLayerEditorWidgetContainerService, HsLayerFolderWidgetComponent, HsLayerListComponent, HsLayerListService, HsLayerManagerComponent, HsLayerManagerGalleryComponent, HsLayerManagerModule, HsLayerManagerRemoveAllDialogComponent, HsLayerManagerRemoveLayerDialogComponent, HsLayerManagerTimeEditorComponent, HsLayerPhysicalListComponent, HsLayerTypeSwitcherWidgetComponent, HsLegendWidgetComponent, HsMetadataWidgetComponent, HsOpacityWidgetComponent, HsScaleWidgetComponent, HsTypeWidgetComponent };