import * as i0 from '@angular/core';
import { ViewRef, OnInit, EventEmitter, AfterContentInit, AfterViewInit, ElementRef } from '@angular/core';
import { HsAddDataCatalogueService, HsAddDataCatalogueMapService, HsAddDataCommonFileService, HsAddDataUrlService, HsAddDataCommonService, HsAddDataVectorService, HsUrlArcGisService, HsAddDataOwsService, HsUrlWfsService, HsUrlWmsService, HsUrlWmtsService, HsUrlXyzService, HsAddDataService } from 'hslayers-ng/services/add-data';
import { HsAddDataLayerDescriptor, HsEndpoint, WhatToAddDescriptor, IntersectWithTooltip, FileDataObject, VectorDataObject, HsLayerDescriptor, Service, HsUrlTypeServiceModel, AddDataUrlType, UrlDataObject, AddDataFileType, AccessRightsModel, FileDescriptor, DatasetType } from 'hslayers-ng/types';
import { HsConfig } from 'hslayers-ng/config';
import { HsDialogComponent, HsDialogContainerService } from 'hslayers-ng/common/dialogs';
import * as i9 from 'hslayers-ng/common/layman';
import { HsCommonLaymanService } from 'hslayers-ng/common/layman';
import { HsLanguageService } from 'hslayers-ng/services/language';
import { HsLaymanService } from 'hslayers-ng/services/save-map';
import { HsLayoutService } from 'hslayers-ng/services/layout';
import * as i5 from 'hslayers-ng/common/upload';
import { HsUploadedFiles, HsUploadComponent } from 'hslayers-ng/common/upload';
import * as ol_renderer_Layer from 'ol/renderer/Layer';
import { Layer } from 'ol/layer';
import { Source } from 'ol/source';
import { HsLayerManagerService } from 'hslayers-ng/services/layer-manager';
import * as i2 from '@angular/common';
import * as i3 from '@angular/forms';
import { FormGroup } from '@angular/forms';
import * as i4 from '@ngx-translate/core';
import * as i10 from '@ng-bootstrap/ng-bootstrap';
import { NgbAccordionDirective } from '@ng-bootstrap/ng-bootstrap';
import * as i10$1 from 'hslayers-ng/common/add-to-map';
import * as i12 from 'hslayers-ng/common/pipes';
import { HsEventBusService } from 'hslayers-ng/services/event-bus';
import * as i9$1 from 'hslayers-ng/common/history-list';
import { HsHistoryListService } from 'hslayers-ng/common/history-list';
import * as i7 from 'hslayers-ng/common/layer-table';
import { HsLogService } from 'hslayers-ng/services/log';
import { HsShareUrlService } from 'hslayers-ng/services/share';
import { HttpClient } from '@angular/common/http';
import { HsMapService } from 'hslayers-ng/services/map';
import { Observable } from 'rxjs';
import * as i5$1 from 'hslayers-ng/common/panels';
import { HsPanelBaseComponent } from 'hslayers-ng/common/panels';

declare class HsCatalogueMetadataComponent implements HsDialogComponent {
    hsConfig: HsConfig;
    hsAddDataCatalogueService: HsAddDataCatalogueService;
    hsAddDataCatalogueMapService: HsAddDataCatalogueMapService;
    hsDialogContainerService: HsDialogContainerService;
    private hsMapService;
    data: i0.InputSignal<{
        selectedLayer: HsAddDataLayerDescriptor;
        selectedDS: HsEndpoint;
    }>;
    selectedLayer: i0.Signal<HsAddDataLayerDescriptor>;
    selectedDS: i0.Signal<HsEndpoint>;
    endpointType: i0.Signal<string>;
    addAvailable: i0.Signal<boolean>;
    availableTypes: i0.Signal<any[]>;
    metadataUrl: i0.Signal<string>;
    bbox: i0.Signal<number[]>;
    viewRef: ViewRef;
    excludedKeys: string[];
    /**
     * @param type - Type in which the layer shall be added (WMS, WFS, etc.)
     */
    addLayerToMap(type: string): Promise<void>;
    private isMickaLayer;
    private isLaymanLayer;
    close(): void;
    /**
     * ZoomTo to selected layer overview
     * Micka layers bbox is defined in EPSG:4326
     * Layman layers bbox is defined in EPSG:3857 (using bounding_box property)
     */
    zoomTo(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCatalogueMetadataComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsCatalogueMetadataComponent, "hs-catalogue-metadata", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HsCatalogueMetadataService {
    decomposeMetadata(input: any, prestring?: string): any;
    decomposeObject(obj: any, substring?: string): any;
    decomposeArray(arr: any[], substring: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCatalogueMetadataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCatalogueMetadataService>;
}

declare class HsAddDataCatalogueComponent implements OnInit {
    hsLanguageService: HsLanguageService;
    hsConfig: HsConfig;
    hsAddDataCatalogueService: HsAddDataCatalogueService;
    hsAddDataCatalogueMapService: HsAddDataCatalogueMapService;
    hsLayoutService: HsLayoutService;
    hsLaymanService: HsLaymanService;
    hsCommonLaymanService: HsCommonLaymanService;
    private hsAddDataService;
    types: any[];
    data: any;
    advancedSearch: boolean;
    filterTypeMenu: i0.WritableSignal<boolean>;
    optionsButtonLabel: i0.Signal<"less" | "more">;
    readonly textFieldTypes: string[];
    readonly dataTypes: string[];
    readonly sortbyTypes: string[];
    constructor();
    ngOnInit(): void;
    layerSelected(layer: HsAddDataLayerDescriptor): void;
    toggleFilterTypeMenu(): void;
    queryByFilter(): void;
    selectType(type: string): void;
    selectQueryType(type: string, query: string): void;
    highlightLayer(layer: any, state: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataCatalogueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataCatalogueComponent, "hs-add-data-catalogue", never, {}, {}, never, never, true, never>;
}

declare class HsCatalogueListItemComponent {
    private hsDatasourcesMetadataService;
    hsAddDataCatalogueService: HsAddDataCatalogueService;
    private hsDialogContainerService;
    private hsLaymanBrowserService;
    private hsLog;
    private hsRemoveLayerDialogService;
    private hsCommonLaymanService;
    layer: i0.InputSignal<HsAddDataLayerDescriptor>;
    title: i0.Signal<string>;
    abstract: i0.Signal<any>;
    layerAvailable: i0.Signal<boolean>;
    explanationsVisible: boolean;
    metadata: any;
    selectTypeToAddLayerVisible: boolean;
    whatToAdd: WhatToAddDescriptor;
    whatToAddTypes: string[];
    loadingInfo: boolean;
    loadingMetadata: boolean;
    /**
     * Toggle add layer options
     */
    toggleAddOptions(): void;
    /**
     * Get layer descriptor, show available options or add to map directly if only WFS available
     */
    private describeCatalogueLayer;
    abortAdd(): void;
    /**
     * Add layer by type click wrapper. Prevents bubbling of DOM event
     * @param type - One of 'WMS', 'WFS'
     * @param event - Mouse click event
     */
    selectTypeAndAdd(type: string, event: MouseEvent): Promise<void>;
    toggleExplanations(): void;
    /**
     * Show metadata record dialog window for selected layer.
     * @param endpoint - Datasource of selected layer
     * @param layer - Metadata record of selected layer
     */
    showMetadata(): Promise<void>;
    /**
     * Show permissions dialog window for selected layer.
     * @param layer - Metadata record of selected layer
     */
    showPermissions(): Promise<void>;
    /**
     * @param endpoint - Datasource of selected layer
     * @param layer - Metadata record of selected layer
     * @returns URL to record file
     */
    layerRDF(endpoint: HsEndpoint, layer: any): string;
    /**
     * Removes selected drawing layer from both Layermanager and Layman
     * @param layer - Metadata record of selected layer
     */
    removeLayer(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCatalogueListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsCatalogueListItemComponent, "hs-catalogue-list-item", never, { "layer": { "alias": "layer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type VectorFileDataType = IntersectWithTooltip<Partial<FileDataObject> & VectorDataObject>;
declare class HsAdvancedOptionsComponent implements OnInit {
    private hsAddDataVectorService;
    data: VectorFileDataType;
    isKml: boolean;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAdvancedOptionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAdvancedOptionsComponent, "hs-advanced-options", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsSaveToLaymanComponent {
    data: FileDataObject;
    descriptionVisible: boolean;
    constructor();
    setSaveToLayman(save: boolean): void;
    toggleDescVisibility(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsSaveToLaymanComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsSaveToLaymanComponent, "hs-save-to-layman", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsNewLayerFormComponent implements OnInit {
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    private hsFileService;
    hsLaymanService: HsLaymanService;
    advancedPanelVisible: boolean;
    data: FileDataObject;
    allowedStyles: {
        list: string;
        title: string;
    };
    ngOnInit(): void;
    read(evt: HsUploadedFiles): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsNewLayerFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsNewLayerFormComponent, "hs-new-layer-form", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsPositionComponent {
    hsLayerManagerService: HsLayerManagerService;
    addUnder: Layer<Source> | null;
    addUnderChange: EventEmitter<Layer<Source, ol_renderer_Layer.default<any>>>;
    updateChanges(): void;
    /**
     * Filter layers by showInLayermanager property
     * This function is passed as filter pipe function
     */
    layerInManager: (layer: HsLayerDescriptor) => boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsPositionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsPositionComponent, "hs-target-position", never, { "addUnder": { "alias": "addUnder"; "required": false; }; }, { "addUnderChange": "addUnderChange"; }, never, never, false, never>;
}

declare class HsAddLayerAuthorizedComponent {
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    hsLaymanService: HsLaymanService;
    data: FileDataObject;
    add(): Promise<void>;
    private hasNameAndSrs;
    canAdd(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddLayerAuthorizedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddLayerAuthorizedComponent, "hs-add-layer-authorized", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsAddDataCommonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsAddDataCommonModule, [typeof HsAdvancedOptionsComponent, typeof HsSaveToLaymanComponent, typeof HsNewLayerFormComponent, typeof HsPositionComponent, typeof HsAddLayerAuthorizedComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof i9.HsLaymanCurrentUserComponent, typeof i10.NgbProgressbarModule, typeof i10$1.HsAddToMapButtonComponent, typeof i12.EpsgPipe, typeof i12.FilterPipe, typeof i9.HsCommonLaymanAccessRightsComponent], [typeof HsAdvancedOptionsComponent, typeof HsSaveToLaymanComponent, typeof HsNewLayerFormComponent, typeof HsPositionComponent, typeof HsAddLayerAuthorizedComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsAddDataCommonModule>;
}

declare class HsUrlAddComponent {
    hsAddDataUrlService: HsAddDataUrlService;
    services?: Service[];
    layers: {
        name: string;
        checked: boolean;
    }[];
    injectedService: HsUrlTypeServiceModel;
    _selectAll: boolean;
    /**
     * Select all records from service.
     */
    selectAll(): void;
    checkAllRecords(records: any[]): void;
    add(): Promise<void>;
    changed(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlAddComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlAddComponent, "hs-url-add", never, { "services": { "alias": "services"; "required": false; }; "layers": { "alias": "layers"; "required": false; }; "injectedService": { "alias": "injectedService"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsUrlDetailsComponent implements AfterContentInit {
    hsAddDataCommonService: HsAddDataCommonService;
    injectedService: HsUrlTypeServiceModel;
    type: AddDataUrlType;
    data: UrlDataObject;
    getDimensionValues: any;
    advancedPanelVisible: boolean;
    ngAfterContentInit(): void;
    srsChanged(): void;
    setBase(state: boolean): void;
    setGroup(state: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlDetailsComponent, "hs-url-details", never, { "injectedService": { "alias": "injectedService"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsUrlProgressComponent {
    hsEventBusService: HsEventBusService;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlProgressComponent, "hs-url-progress", never, {}, {}, never, never, false, never>;
}

declare class HsCommonUrlComponent {
    private historyListService;
    items: any;
    what: any;
    type: any;
    url: any;
    urlChange: EventEmitter<any>;
    connect: EventEmitter<any>;
    constructor();
    emitConnect(): void;
    change(): void;
    historySelected(url: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCommonUrlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsCommonUrlComponent, "hs-common-url", never, { "type": { "alias": "type"; "required": false; }; "url": { "alias": "url"; "required": false; }; }, { "urlChange": "urlChange"; "connect": "connect"; }, never, never, false, never>;
}

declare class HsAddUrlAsToggleComponent {
    isBase: i0.InputSignal<boolean>;
    isGroup: i0.InputSignal<boolean>;
    showGroupToggle: i0.InputSignal<boolean>;
    baseChange: i0.OutputEmitterRef<boolean>;
    groupChange: i0.OutputEmitterRef<boolean>;
    setBase(state: boolean): void;
    setGroup(state: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddUrlAsToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddUrlAsToggleComponent, "hs-add-as-toggle", never, { "isBase": { "alias": "isBase"; "required": false; "isSignal": true; }; "isGroup": { "alias": "isGroup"; "required": false; "isSignal": true; }; "showGroupToggle": { "alias": "showGroupToggle"; "required": false; "isSignal": true; }; }, { "baseChange": "baseChange"; "groupChange": "groupChange"; }, never, never, false, never>;
}

declare class HsCommonUrlModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCommonUrlModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsCommonUrlModule, [typeof HsUrlAddComponent, typeof HsUrlProgressComponent, typeof HsCommonUrlComponent, typeof HsUrlDetailsComponent, typeof HsAddUrlAsToggleComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof i9$1.HsHistoryListModule, typeof i10$1.HsAddToMapButtonComponent, typeof i12.EpsgPipe, typeof i12.TrackByPropertyPipe, typeof i7.HsLayerTableComponent], [typeof HsUrlAddComponent, typeof HsUrlProgressComponent, typeof HsCommonUrlComponent, typeof HsUrlDetailsComponent, typeof HsAddUrlAsToggleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsCommonUrlModule>;
}

declare class HsAddDataFileComponent {
    hsConfig: HsConfig;
    hsLanguageService: HsLanguageService;
    typeSelected: AddDataFileType;
    types: {
        id: AddDataFileType;
        text: string;
    }[];
    constructor();
    selectType(type: AddDataFileType): void;
    isVectorType(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataFileComponent, "hs-add-data-file", never, {}, {}, never, never, false, never>;
}

declare class HsAddDataFileBaseComponent implements OnInit, AfterViewInit {
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    hsLayoutService: HsLayoutService;
    hsConfig: HsConfig;
    app: string;
    data: FileDataObject;
    fileInput: ElementRef;
    acceptedFormats: string;
    baseFileType: AddDataFileType;
    private destroyRef;
    hsUploadComponent: HsUploadComponent;
    clearInput(): void;
    ngAfterViewInit(): void;
    ngOnInit(): void;
    /**
     * Reset data object to its default values
     */
    setDataToDefault(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataFileBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataFileBaseComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class HsFileService {
    hsLanguageService: HsLanguageService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    fileUploadErrorHeader: string;
    read(evt: HsUploadedFiles, readAsText?: boolean): Promise<void>;
    checkShpFiles(data: FileDataObject): void;
    checkRasterFiles(data: FileDataObject): void;
    tooManyFiles(allowed: number, length: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsFileService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsFileService>;
}

declare class HsFileShpComponent extends HsAddDataFileBaseComponent implements OnInit, AfterViewInit {
    hsFileService: HsFileService;
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    hsLayoutService: HsLayoutService;
    hsConfig: HsConfig;
    fileType: AddDataFileType;
    ngAfterViewInit(): void;
    ngOnInit(): void;
    handleFileUpload(evt: HsUploadedFiles): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsFileShpComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsFileShpComponent, "hs-file-shp", never, {}, {}, never, never, false, never>;
}

declare class HsFileShpModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsFileShpModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsFileShpModule, [typeof HsFileShpComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof i5.HsUploadModule, typeof HsAddDataCommonModule], [typeof HsFileShpComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsFileShpModule>;
}

declare class HsAddDataVectorFileComponent implements OnInit, AfterViewInit {
    private hsAddDataVectorService;
    private hsAddDataVectorUploadService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    private hsCommonLaymanService;
    private hsConfig;
    hsLanguageService: HsLanguageService;
    private hsLayerManagerService;
    private hsLayoutService;
    private hsMapService;
    private hsToastService;
    fileType: 'geojson' | 'kml' | 'gpx';
    hsUploadComponent: HsUploadComponent;
    app: string;
    acceptedFormats: string;
    uploadType: string;
    data: VectorFileDataType;
    fileInput: ElementRef;
    access_rights: AccessRightsModel;
    private destroyRef;
    ngAfterViewInit(): void;
    ngOnInit(): void;
    getAcceptedFormats(): void;
    /**
     * Handler for adding vector file, file in template.
     */
    add(): Promise<void>;
    /**
     * Upload vector file to Layman then load it as WMS
     * Converts already parsed features into GeoJSON.
     * We intentionally ignore if the file was originally KML or GPX as only GeoJSON is supported natively by Layman.
     */
    addAsWms(): Promise<void>;
    /**
     * After layer has successfully been added to the map, move to LM panel and clean up the code
     */
    moveToLayerManager(): void;
    updateExistingLayer(): Promise<void>;
    handleFileUpload(evt: HsUploadedFiles): void;
    setUploadType(type: string): void;
    setToDefault(): void;
    /**
     * Reset data object to its default values
     */
    setDataToDefault(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataVectorFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataVectorFileComponent, "hs-file-vector", never, { "fileType": { "alias": "fileType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsAddDataVectorUrlComponent implements OnInit {
    hsHistoryListService: HsHistoryListService;
    hsAddDataVectorService: HsAddDataVectorService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    hsLayoutService: HsLayoutService;
    fileType: 'geojson' | 'kml' | 'gpx';
    data: VectorDataObject;
    private destroyRef;
    connect: () => Promise<void>;
    ngOnInit(): void;
    /**
     * Handler for adding non-wms service, file in template.
     */
    add(): Promise<void>;
    /**
     * Reset data object to its default values
     */
    setDataToDefault(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataVectorUrlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataVectorUrlComponent, "hs-url-vector", never, { "fileType": { "alias": "fileType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsAddDataVectorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataVectorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsAddDataVectorModule, [typeof HsAddDataVectorFileComponent, typeof HsAddDataVectorUrlComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof HsAddDataCommonModule, typeof HsCommonUrlModule, typeof i9.HsLaymanCurrentUserComponent, typeof i5.HsUploadModule, typeof i10$1.HsAddToMapButtonComponent], [typeof HsAddDataVectorFileComponent, typeof HsAddDataVectorUrlComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsAddDataVectorModule>;
}

declare class HsFileRasterComponent extends HsAddDataFileBaseComponent implements OnInit {
    hsFileService: HsFileService;
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    hsLayoutService: HsLayoutService;
    hsConfig: HsConfig;
    fileType: Extract<AddDataFileType, 'raster' | 'raster-ts'>;
    ngOnInit(): void;
    handleFileUpload(evt: HsUploadedFiles): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsFileRasterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsFileRasterComponent, "hs-file-raster", never, { "fileType": { "alias": "fileType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RasterTimeseriesComponent implements OnInit {
    private fb;
    private hsToastService;
    private hsAddDataCommonFileService;
    data: FileDataObject;
    accordion: NgbAccordionDirective;
    fileTitleInput: ElementRef<HTMLInputElement>;
    private destroyRef;
    form: FormGroup;
    formVisible: boolean;
    tsData: FileDescriptor;
    fileTitle: string;
    selectedString: string;
    supportedRegex: {
        regex: RegExp;
        timeregex: string;
    }[];
    constructor();
    ngOnInit(): void;
    private getFileTitle;
    /** On click handler used by user to mark inferred inputs as verified */
    verifyInputs(): void;
    /**
     * Checks the validity of the selected string
     * String is valid if:
     * - matches one of the following regex datetime formats
     *    -[0-9]\{8\}T[0-9]\{9\}Z eg 20220510T050948Z
     *    -[0-9]\{8\}T[0-9]\{9\} eg. 20220510T050948
     * - consist of digits only or digits and separators  ., _, /, or -
     */
    private checkStringValidity;
    selectDateString(e: MouseEvent): void;
    /**
     * Get first special character from string selected by user
     * Assuming it's separator
     */
    private getSeparator;
    /**
     *Infer regex pattern from selected string
     */
    inferRegexPatternFromString(timestamp: string, regex: string): string;
    /**
     * Extract selected text from element.
     * Necessary workaround because of Firefox bug https://bugzilla.mozilla.org/show_bug.cgi?id=85686
     */
    private getSelectedText;
    private resetSelection;
    /**
     * Reset form controls to default values
     */
    private resetForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<RasterTimeseriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RasterTimeseriesComponent, "hs-file-raster-timeseries", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsFileRasterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsFileRasterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsFileRasterModule, [typeof HsFileRasterComponent, typeof RasterTimeseriesComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof HsAddDataCommonModule, typeof HsCommonUrlModule, typeof i4.TranslatePipe, typeof i5.HsUploadModule, typeof i10.NgbAccordionModule], [typeof HsFileRasterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsFileRasterModule>;
}

declare class HsAddDataFileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataFileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsAddDataFileModule, [typeof HsAddDataFileComponent, typeof HsAddDataFileBaseComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof HsFileShpModule, typeof HsAddDataVectorModule, typeof HsFileRasterModule], [typeof HsAddDataFileComponent, typeof HsAddDataFileBaseComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsAddDataFileModule>;
}

declare const AddDataFileValues: Array<{
    id: AddDataFileType;
    text: string;
}>;

declare class HsUrlArcGisComponent {
    hsAddDataCommonService: HsAddDataCommonService;
    hsUrlArcGisService: HsUrlArcGisService;
    hsAddDataOwsService: HsAddDataOwsService;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlArcGisComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlArcGisComponent, "hs-url-arcgis", never, {}, {}, never, never, false, never>;
}

declare class HsUrlArcGisModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlArcGisModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsUrlArcGisModule, [typeof HsUrlArcGisComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof HsAddDataCommonModule, typeof HsCommonUrlModule], [typeof HsUrlArcGisComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsUrlArcGisModule>;
}

declare class HsUrlWfsComponent {
    hsUrlWfsService: HsUrlWfsService;
    hsAddDataOwsService: HsAddDataOwsService;
    hsAddDataCommonService: HsAddDataCommonService;
    title: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlWfsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlWfsComponent, "hs-url-wfs", never, {}, {}, never, never, false, never>;
}

declare class HsUrlWfsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlWfsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsUrlWfsModule, [typeof HsUrlWfsComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof HsAddDataCommonModule, typeof HsCommonUrlModule, typeof i7.HsLayerTableComponent], [typeof HsUrlWfsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsUrlWfsModule>;
}

declare class HsUrlWmsComponent {
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataOwsService: HsAddDataOwsService;
    hsUrlWmsService: HsUrlWmsService;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlWmsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlWmsComponent, "hs-url-wms", never, {}, {}, never, never, false, never>;
}

declare class HsUrlWmsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlWmsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsUrlWmsModule, [typeof HsUrlWmsComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof HsAddDataCommonModule, typeof HsCommonUrlModule], [typeof HsUrlWmsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsUrlWmsModule>;
}

declare class HsUrlWmtsComponent {
    hsAddDataOwsService: HsAddDataOwsService;
    hsUrlWmtsService: HsUrlWmtsService;
    hsAddDataCommonService: HsAddDataCommonService;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlWmtsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlWmtsComponent, "hs-url-wmts", never, {}, {}, never, never, false, never>;
}

declare class HsUrlWmtsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlWmtsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsUrlWmtsModule, [typeof HsUrlWmtsComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof HsAddDataCommonModule, typeof HsCommonUrlModule, typeof i7.HsLayerTableComponent], [typeof HsUrlWmtsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsUrlWmtsModule>;
}

declare class HsAddDataUrlComponent implements OnInit {
    hsConfig: HsConfig;
    hsLanguageService: HsLanguageService;
    hsShareUrlService: HsShareUrlService;
    hsLog: HsLogService;
    hsLayoutService: HsLayoutService;
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataOwsService: HsAddDataOwsService;
    hsAddDataUrlService: HsAddDataUrlService;
    hsDialogContainerService: HsDialogContainerService;
    types: {
        id: AddDataUrlType;
        text: string;
    }[];
    ngOnInit(): void;
    selectType(type: AddDataUrlType): void;
    connectServiceFromUrlParam(type: AddDataUrlType): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataUrlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataUrlComponent, "hs-add-data-url", never, {}, {}, never, never, false, never>;
}

declare class HsUrlGeoSparqlService {
    httpClient: HttpClient;
    hsEventBusService: HsEventBusService;
    hsLanguageService: HsLanguageService;
    hsLog: HsLogService;
    hsAddDataUrlService: HsAddDataUrlService;
    private hsToastService;
    data: UrlDataObject;
    constructor();
    verifyEndpoint(url: string): Promise<boolean>;
    /**
     * Searches for variables (words beginning on question mark) in the query string and returns an array of the variables found.
     * The regex pattern for allowed variable characters is created based on:
     * https://www.w3.org/TR/sparql11-query/#rVARNAME
     */
    findParamsInQuery(query: string): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlGeoSparqlService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsUrlGeoSparqlService>;
}

declare class HsUrlGeoSparqlComponent {
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataCommonFileService: HsAddDataCommonFileService;
    hsAddDataVectorService: HsAddDataVectorService;
    hsHistoryListService: HsHistoryListService;
    hsLayoutService: HsLayoutService;
    hsUrlGeoSparqlService: HsUrlGeoSparqlService;
    querySuccessful: boolean;
    showDetails: boolean;
    validEndpoint: boolean;
    data: {
        abstract?: string;
        geomProperty?: string;
        idProperty?: string;
        name?: string;
        properties?: string[];
        query?: string;
        type: string;
        title?: string;
        url?: string;
    };
    constructor();
    connect: () => Promise<void>;
    add(): Promise<void>;
    findParamsInQuery(): void;
    private setDataToDefault;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlGeoSparqlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlGeoSparqlComponent, "hs-url-geosparql", never, {}, {}, never, never, false, never>;
}

declare class HsUrlGeoSparqlModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlGeoSparqlModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsUrlGeoSparqlModule, [typeof HsUrlGeoSparqlComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof HsAddDataCommonModule, typeof HsCommonUrlModule, typeof i4.TranslatePipe, typeof i10$1.HsAddToMapButtonComponent], [typeof HsUrlGeoSparqlComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsUrlGeoSparqlModule>;
}

declare class HsUrlXyzComponent implements OnInit {
    hsUrlXyzService: HsUrlXyzService;
    hsAddDataCommonService: HsAddDataCommonService;
    hsAddDataOwsService: HsAddDataOwsService;
    data: UrlDataObject;
    advancedPanelVisible: boolean;
    ngOnInit(): void;
    add(): Promise<void>;
    setBase(state: boolean): void;
    setApiKey(state: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlXyzComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsUrlXyzComponent, "hs-url-xyz", never, {}, {}, never, never, false, never>;
}

declare class HsUrlXyzModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsUrlXyzModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsUrlXyzModule, [typeof HsUrlXyzComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof HsAddDataCommonModule, typeof HsCommonUrlModule, typeof i7.HsLayerTableComponent, typeof i10$1.HsAddToMapButtonComponent], [typeof HsUrlXyzComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsUrlXyzModule>;
}

declare class HsAddDataUrlModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataUrlModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsAddDataUrlModule, [typeof HsAddDataUrlComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof HsAddDataVectorModule, typeof HsUrlArcGisModule, typeof HsUrlGeoSparqlModule, typeof HsUrlWfsModule, typeof HsUrlWmsModule, typeof HsUrlWmtsModule, typeof HsUrlXyzModule], [typeof HsAddDataUrlComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsAddDataUrlModule>;
}

declare const AddDataUrlValues: Array<{
    id: AddDataUrlType;
    text: string;
}>;

declare class HsVectorUrlParserService {
    hsMapService: HsMapService;
    hsShareUrlService: HsShareUrlService;
    hsAddDataVectorService: HsAddDataVectorService;
    constructor();
    checkUrlParamsAndAdd: () => Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsVectorUrlParserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsVectorUrlParserService>;
}

declare class HsAddDataComponent extends HsPanelBaseComponent implements OnInit {
    hsAddDataService: HsAddDataService;
    hsShareUrlService: HsShareUrlService;
    hsAddDataUrlService: HsAddDataUrlService;
    private hsDialogContainerService;
    hsAddDataCatalogueService: HsAddDataCatalogueService;
    private hsRemoveLayerDialogService;
    private hsLaymanService;
    private hsLayerSynchronizerService;
    layersAvailable: Observable<boolean>;
    constructor();
    name: string;
    selectDatasetType(type: DatasetType): void;
    ngOnInit(): void;
    connectServiceFromUrlParam(type: AddDataUrlType): void;
    /**
     * Create remove-layer dialog which allows for single/multiple layer removal
     */
    removeMultipleLayers(): Promise<void>;
    /**
     * Remove all user's layers from Layman catalogue
     */
    removeAllLayers(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsAddDataComponent, "hs-add-data", never, {}, {}, never, never, false, never>;
}

declare class HsAddDataModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsAddDataModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsAddDataModule, [typeof HsAddDataComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.TranslatePipe, typeof i5$1.HsPanelHelpersModule, typeof HsAddDataUrlModule, typeof HsAddDataFileModule, typeof HsAddDataCatalogueComponent, typeof i5$1.HsPanelHeaderComponent], [typeof HsAddDataComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsAddDataModule>;
}

declare const DEFAULT_SHP_LOAD_TYPE: "wms";
declare const DEFAULT_VECTOR_LOAD_TYPE: "wfs";

export { AddDataFileValues, AddDataUrlValues, DEFAULT_SHP_LOAD_TYPE, DEFAULT_VECTOR_LOAD_TYPE, HsAddDataCatalogueComponent, HsAddDataCommonModule, HsAddDataComponent, HsAddDataFileBaseComponent, HsAddDataFileComponent, HsAddDataFileModule, HsAddDataModule, HsAddDataUrlComponent, HsAddDataUrlModule, HsAddDataVectorFileComponent, HsAddDataVectorModule, HsAddDataVectorUrlComponent, HsAddLayerAuthorizedComponent, HsAddUrlAsToggleComponent, HsAdvancedOptionsComponent, HsCatalogueListItemComponent, HsCatalogueMetadataComponent, HsCatalogueMetadataService, HsCommonUrlComponent, HsCommonUrlModule, HsFileRasterComponent, HsFileRasterModule, HsFileService, HsFileShpComponent, HsFileShpModule, HsNewLayerFormComponent, HsPositionComponent, HsSaveToLaymanComponent, HsUrlAddComponent, HsUrlArcGisComponent, HsUrlArcGisModule, HsUrlDetailsComponent, HsUrlGeoSparqlComponent, HsUrlGeoSparqlModule, HsUrlGeoSparqlService, HsUrlProgressComponent, HsUrlWfsComponent, HsUrlWfsModule, HsUrlWmsComponent, HsUrlWmsModule, HsUrlWmtsComponent, HsUrlWmtsModule, HsVectorUrlParserService };
export type { VectorFileDataType };