import { Layer, Image, Vector } from 'ol/layer';
import { Observable } from 'rxjs';
import { Source, ImageStatic, Vector as Vector$1 } from 'ol/source';
import { LaymanCompositionDescriptor, HslayersLayerJSON } from 'hslayers-ng/types';
import * as i0 from '@angular/core';
import * as ol_renderer_Layer from 'ol/renderer/Layer';
import { Feature } from 'ol';

declare class HsCompositionsParserService {
    private hsMapService;
    private hsConfig;
    private $http;
    private hsProxyService;
    private hsCompositionsLayerParserService;
    private hsDialogContainerService;
    private hsLayoutService;
    private $log;
    private hsEventBusService;
    private hsLanguageService;
    private hsCommonLaymanService;
    private hsLayerManagerService;
    private hsToastService;
    private hsLayerManagerVisibilityService;
    /**
     * Layman composition record
     * holds access_rights
     */
    currentCompositionRecord: Observable<LaymanCompositionDescriptor>;
    /**
     * Stores current composition URL if there is one or NULL
     */
    composition_loaded: any;
    /**
     * Stores whether current composition was edited (for composition changes, saving etc.)
     */
    composition_edited: boolean;
    /**
     * Stores title of current composition
     */
    current_composition_title: string;
    current_composition_url: string;
    loadingOptions: {
        suspendZoomingToExtent: boolean;
        suspendPanelChange: boolean;
    };
    constructor();
    /**
     * Load selected composition from server, parse it and add layers to map.
     * Optionally (based on app config) may open layer manager panel
     * @param url - URL of selected composition
     * @param overwrite - Whether overwrite current composition in map -
     * remove all layers from maps which originate from composition (if not pasted, it counts as "true")
     * @param callback - Optional function which should be called when composition is successfully loaded
     * @param pre_parse - Optional function for pre-parsing loaded data about composition to accepted format
     */
    loadUrl(url: string | any, //CSW record object
    overwrite?: boolean, callback?: any, pre_parse?: any): Promise<void>;
    /**
     * Check if the response holds the composition data and try to load the composition object
     * @param response - Response from HTTP GET request requesting composition data
     * @param pre_parse - Function for pre-parsing loaded data about composition to accepted format
     * @param url - URL of selected composition
     * @param overwrite - Whether overwrite current composition in map -
     * remove all layers from maps which originate from composition (if not pasted, it counts as "true")
     * @param callback - Function which should be called when composition is successfully loaded
     */
    loaded(response: any, pre_parse: any, url: any, overwrite: boolean, callback: any): Promise<void>;
    /**
     * Parse URL from CSW composition format layer/service
     */
    parseCSWLayer(layer: any): {
        type: "wfs" | "wms" | "wmts" | "kml" | "gpx" | "geojson" | "arcgis" | "geosparql" | "xyz";
        title: any;
        url: any;
        id: `${string}-${string}-${string}-${string}-${string}`;
    };
    /**
     * Parse CSW composition record extracting layers
     */
    getCSWLayers(record: any): {
        layers: any[];
        services: any[];
    };
    parseCSW(response: any): Promise<{}>;
    /**
     * Parse WMC to JSON object
     * @param response - Response from http get request requesting composition data
     */
    parseWMC(response: any): any;
    /**
     * Check if the response indicates a successful data request
     * @param response - Response from HTTP GET request requesting composition data
     */
    checkLoadSuccess(response: any): boolean;
    loadCompositionObject(obj: any, overwrite: boolean, titleFromContainer?: boolean, extentFromContainer?: string | Array<number>): Promise<boolean>;
    /**
     * Finalize composition loading to the OL map
     * @param responseData - Response from http get request requesting composition data
     */
    finalizeCompositionLoading(responseData: any): void;
    /**
     * Create an error message in case of on an unsuccessful composition load
     * @param response - Response from http get request requesting composition data
     */
    raiseCompositionLoadError(response: any): void;
    /**
     * Send Ajax request to selected server to gain information about composition
     * @param url - Url to composition info
     * @returns Object containing composition info
     */
    loadInfo(url: string): Promise<any>;
    /**
     * Parse Micka datasource WMC info to JSON object
     * @param response - Response from http get request requesting composition data
     * @returns Object containing composition info
     */
    parseMickaWmcInfo(response: any): any;
    parseMickaCSWInfo(response: string): {
        title: any;
        abstract: any;
        extent: number[];
    };
    getCSWKeyWords(keywordInfo: any): any[];
    /**
     * Load and display a warning dialog about out of bounds extent
     * @param extent - Extent value
     */
    loadWarningBootstrap(extent: any): void;
    /**
     * Parse composition object to extract individual layers and add them to map
     * @param j - Composition object with Layers
     * @returns Array of created layers
     */
    jsonToLayers(j: any): Promise<Layer<Source>[]>;
    /**
     * Select correct layer parser for input data based on layer "className" property (ArcGISRest, WMS, WFS)
     * @param lyr_def - Layer to be created (encapsulated in layer definition object)
     * Parser function to create layer (using config_parsers service)
     */
    jsonToLayer(lyr_def: HslayersLayerJSON): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCompositionsParserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCompositionsParserService>;
}

declare class HsCompositionsLayerParserService {
    private hsMapService;
    private hsAddDataVectorService;
    private hsStylerService;
    private hsLanguageService;
    private hsLog;
    private hsToastService;
    private hsCommonLaymanService;
    private hsCommonLaymanLayerService;
    private hsAddDataOwsService;
    /**
     * Initiate creation of WFS layer through HsUrlWfsService
     * Create WFS layer from capabilities
     *
     * @param lyr_def - Layer definition object
     */
    createWFSLayer(lyr_def: any): Promise<Layer<Source>>;
    /**
     * Parse definition object to create WMTS Ol.layer  (source = ol.source.WMTS)
     * @param lyr_def - Layer definition object
     * @returns Ol Tile layer
     */
    createWMTSLayer(lyr_def: any): Promise<Layer<Source>>;
    /**
     * Get WMS layer options
     * @param lyr_def - Layer definition object
     * @returns WMS layer options
     */
    private getWmsLayerOptions;
    /**
     * Parse definition object to create WMS Ol.layer  (source = ol.source.ImageWMS / ol.source.TileWMS)
     * @param lyr_def - Layer definition object
     * @returns Ol Image or Tile layer
     */
    createWmsLayer(lyr_def: any): Promise<Layer<Source, ol_renderer_Layer.default<any>>>;
    /**
     * Parse definition object to create ArcGIS Ol.layer  (source = ol.source.ImageArcGISRest / ol.source.TileArcGISRest)
     * @param lyr_def - Layer definition object
     * @returns Ol Image or Tile layer
     */
    createArcGISLayer(lyr_def: any): Promise<Layer<Source, ol_renderer_Layer.default<any>>>;
    /**
     * Parse definition object to create XYZ Ol.layer
     * @param lyr_def - Layer definition object
     * @returns Ol Image or Tile layer
     */
    createXYZLayer(lyr_def: any): Promise<Layer<Source, ol_renderer_Layer.default<any>>>;
    /**
     * Parse definition object to create ImageStatic Ol.layer
     * @param lyr_def - Layer definition object
     * @returns OL Image or Tile layer
     */
    createStaticImageLayer(lyr_def: any): Image<ImageStatic>;
    /**
     * Parse definition object to create Sparql layer
     * @param lyr_def - Layer definition object
     */
    createSparqlLayer(lyr_def: any): Promise<Vector<Vector$1<Feature>>>;
    /**
     * Get layer legends
     * @param lyr_def - Layer definition object
     */
    getLegends(lyr_def: any): string[];
    /**
     * Parse definition object to create Vector layer (classic Ol.vector, KML, GeoJSON, WFS, Sparql)
     * @param lyr_def - Layer definition object
     * @returns Either valid vector layer or function for creation of other supported vector file types)
     */
    createVectorLayer(lyr_def: any): Promise<Vector<Vector$1<Feature>>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsCompositionsLayerParserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsCompositionsLayerParserService>;
}

export { HsCompositionsLayerParserService, HsCompositionsParserService };