import { SafeHtml, SafeResourceUrl } from '@angular/platform-browser';
import { Layer, Vector } from 'ol/layer';
import { Source, Vector as Vector$1 } from 'ol/source';
import * as i0 from '@angular/core';
import { OnInit } from '@angular/core';
import * as ol_renderer_Layer from 'ol/renderer/Layer';
import { Feature, Map } from 'ol';
import { HsLayerSelectorService } from 'hslayers-ng/services/layer-manager';
import { HsStylerService } from 'hslayers-ng/services/styler';
import BaseLayer from 'ol/layer/Base';
import { HsLanguageService } from 'hslayers-ng/services/language';
import { HsMapService } from 'hslayers-ng/services/map';
import * as i7 from 'hslayers-ng/common/panels';
import { HsPanelBaseComponent } from 'hslayers-ng/common/panels';
import { HsQueuesService } from 'hslayers-ng/services/queues';
import * as i5 from '@angular/common';
import * as i6 from '@angular/forms';
import * as i8 from 'hslayers-ng/common/pipes';
import * as i9 from '@ngx-translate/core';

type HsCustomLegendCategory = {
    /**
     * Unique category name
     */
    name: string;
    /**
     * rgb(a) or hex encoded color string
     * (mutually exclusive with path)
     */
    color?: string;
    /**
     * Path to an icon
     * (mutually exclusive with color)
     */
    path?: string;
    /**
     * Optional height of the icon in pixels
     */
    height?: number;
};

interface HsLegendDescriptor {
    autoLegend?: boolean;
    lyr: Layer<Source>;
    title: string;
    type: string;
    subLayerLegends?: Array<string>;
    visible: boolean;
    svg?: SafeHtml;
}

type LayerLegend = {
    lastLegendImage?: any;
    legendType?: 'image' | 'svg';
    svgContent?: SafeHtml;
    legendImage?: SafeResourceUrl;
};

declare class HsLegendLayerStaticComponent implements OnInit {
    private hsLegendLayerStaticService;
    layer: HsLegendDescriptor;
    layerLegend: LayerLegend;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendLayerStaticComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLegendLayerStaticComponent, "hs-legend-layer-static", never, { "layer": { "alias": "layer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsLegendLayerStaticService {
    private sanitizer;
    fillContent(lyr: Layer<Source>): LayerLegend;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendLayerStaticService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLegendLayerStaticService>;
}

declare class HsLegendLayerVectorComponent {
    svg: string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendLayerVectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLegendLayerVectorComponent, "hs-legend-vector-layer", never, { "svg": { "alias": "svg"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsLegendService {
    hsStylerService: HsStylerService;
    hsLayerSelectorService: HsLayerSelectorService;
    private hsLog;
    private sanitizer;
    private hsProxyService;
    constructor();
    /**
     * Test if layer is visible and has supported type (conditions for displaying legend)
     * @param layer - Layer to test
     * @returns Return if legend might exist for layer and layer is visible
     */
    legendValid(layer: HsLegendDescriptor): boolean;
    /**
     * Get legend graphics for a vector layer based on sld attribute. If no SLD exists, try to generate it from OL style.
     * @param currentLayer - Layer of interest
     * @returns Image as SVG string
     */
    getVectorLayerLegendSvg(currentLayer: Vector<Vector$1<Feature>>): Promise<string>;
    private fixOpacity;
    /**
     * Generate url for GetLegendGraphic request of WMS service for selected layer
     * @param source - Source of wms layer
     * @param layer_name - Name of layer for which legend is requested
     * @param layer - Layer to get legend for
     * @returns Url of the legend graphics
     */
    getLegendUrl(source: Source, layer_name: string, layer: Layer<Source>): string;
    setSvg(layer: Layer<Source>): Promise<SafeHtml>;
    /**
     * Generate SVG linear gradient for layers colormap
     */
    generateInterpolatedLayerLegend(layer: Layer<any>): {
        autoLegend: boolean;
        title: string;
        lyr: Layer<any, ol_renderer_Layer.default<any>>;
        type: string;
        visible: boolean;
        svg: SafeHtml;
    };
    /**
     * (PRIVATE) Generate url for GetLegendGraphic request of WMS service for selected layer
     * @param layer - OpenLayers layer
     * @returns Description of layer to be used for creating the legend. It contains type of layer, sublayer legends, title, visibility etc.
     */
    getLayerLegendDescriptor(layer: Layer<Source>): Promise<HsLegendDescriptor | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HsLegendService>;
}

declare class HsLegendLayerComponent implements OnInit {
    hsLegendService: HsLegendService;
    hsStylerService: HsStylerService;
    layer: HsLegendDescriptor;
    legendCategories: HsCustomLegendCategory[];
    hasLegendCategories: i0.WritableSignal<boolean>;
    /**
     * default icon height in pixels
     * @default 32
     */
    defaultIconHeight: number;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendLayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLegendLayerComponent, "hs-legend-layer", never, { "layer": { "alias": "layer"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HsLegendComponent extends HsPanelBaseComponent implements OnInit {
    hsLegendService: HsLegendService;
    hsMapService: HsMapService;
    hsQueuesService: HsQueuesService;
    hsLanguageService: HsLanguageService;
    layerDescriptors: any[];
    titleSearch: string;
    name: string;
    ngOnInit(): void;
    /**
     * Add selected layer to the list of layers in legend (with event listener
     * to display/hide legend item when layer visibility change)
     * @param layer - Layer to add legend for
     */
    addLayerToLegends(layer: Layer<Source>): Promise<void>;
    rebuildLegends(): void;
    legendFilter: (item: any) => boolean;
    /**
     * Check if there is any visible layer
     * @returns Returns true if no layers with legend exist
     */
    noLayerExists(): boolean;
    /**
     * Remove selected layer from legend items
     * @param layer - Layer to remove from legend
     */
    removeLayerFromLegends(layer: BaseLayer): void;
    buildLegendsForLayers(map: Map): void;
    /**
     * (PRIVATE) Callback function for adding layer to map, add layers legend
     * @param e - Event object, should have element property
     */
    layerAdded(e: any): void;
    /**
     * @param e - event description
     */
    layerVisibilityChanged(e: any): void;
    /**
     * @param e - event description
     */
    layerSourcePropChanged(e: any): void;
    /**
     * Finds layer descriptor for OpenLayers layer
     * @param layer - OpenLayers layer
     * @returns Object describing the legend
     */
    findLayerDescriptor(layer: Layer<Source>): HsLegendDescriptor;
    findLayerDescriptorBySource(source: Source): any;
    refreshList(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HsLegendComponent, "hs-legend", never, {}, {}, never, never, false, never>;
}

declare class HsLegendModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HsLegendModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HsLegendModule, [typeof HsLegendComponent, typeof HsLegendLayerComponent, typeof HsLegendLayerVectorComponent, typeof HsLegendLayerStaticComponent], [typeof i5.CommonModule, typeof i6.FormsModule, typeof i7.HsPanelHelpersModule, typeof i8.FilterPipe, typeof i9.TranslatePipe, typeof i7.HsPanelHeaderComponent], [typeof HsLegendComponent, typeof HsLegendLayerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HsLegendModule>;
}

export { HsLegendComponent, HsLegendLayerComponent, HsLegendLayerStaticComponent, HsLegendLayerStaticService, HsLegendLayerVectorComponent, HsLegendModule, HsLegendService };
export type { HsCustomLegendCategory, HsLegendDescriptor, LayerLegend };