import * as i0 from '@angular/core';
import { InjectionToken, AfterViewInit, OnInit, OnDestroy, ChangeDetectorRef, ModuleWithProviders } from '@angular/core';
import * as Leaflet from 'leaflet';
import Leaflet__default from 'leaflet';
import * as i7 from '@angular/router';
import { Params, ParamMap, ActivatedRoute, Router } from '@angular/router';
import { HttpClient } from '@angular/common/http';
import * as i6 from '@angular/forms';
import { ControlValueAccessor, FormGroup, FormArray } from '@angular/forms';
import { Subscription } from 'rxjs';
import * as i5 from '@angular/common';
import * as i8 from 'adb-shared';
import * as i9 from '@ngx-translate/core';

interface AdbMapConfig {
    api: string;
    artfaktaTaxonLists: string;
    observationPage?: string;
    locationPage?: string;
    dynamic?: boolean;
    filters?: AdbMapFilterType[];
    log?: boolean;
}
declare enum AdbMapFilterType {
    Taxon = "taxon",
    Area = "area",
    OwnArea = "ownArea",
    Time = "time",
    RedList = "redlist",
    RiskList = "risklist",
    TaxaLists = "taxonLists",
    Datasources = "datasources"
}
declare class VisibleFilters {
    showTaxon: boolean;
    showTime: boolean;
    showArea: boolean;
    showOwnArea: boolean;
    showTaxaLists: boolean;
    showDatasets: boolean;
}
declare const ADB_MAP_CONFIG: InjectionToken<AdbMapConfig>;
declare class AdbMapConfigService {
    readonly log: boolean;
    readonly artfaktaTaxonLists: string;
    readonly observationFeatures: string;
    readonly taxaListsApi: string;
    readonly filters: VisibleFilters;
    readonly observationPage: string;
    readonly locationPage: string;
    readonly dynamic: boolean;
    constructor(config: AdbMapConfig);
    private hasFilter;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdbMapConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AdbMapConfigService>;
}

declare class AdbObsMapComponent implements AfterViewInit, OnInit, OnDestroy {
    private activatedRoute;
    private config;
    private router;
    private http;
    private static readonly LOCATION_MARKER_COLOR;
    private static readonly OBS_MARKER_COLOR;
    private static readonly UNCERTAINTY_COLOR;
    private subscriptions;
    error: null;
    mapLoading: i0.WritableSignal<boolean>;
    siteLayer: Leaflet.FeatureGroup;
    hasBox: boolean;
    count: any;
    mapId: string;
    map: any;
    mapReady: i0.WritableSignal<boolean>;
    hasQueryParams: boolean;
    hasUrlParams: boolean;
    queryParams: Params;
    urlParams: ParamMap;
    constructor(activatedRoute: ActivatedRoute, config: AdbMapConfigService, router: Router, http: HttpClient);
    ngAfterViewInit(): void;
    private tryLoad;
    ngOnInit(): void;
    private attachUserListeners;
    private onUserInputRoute;
    private loadFeature;
    private buildMap;
    private getMapBoundsToBbox;
    private createPointLayer;
    private getPolygonStyle;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdbObsMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdbObsMapComponent, "adb-obs-map", never, {}, {}, never, never, false, never>;
}

declare class PolygonDrawerInput implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
    private subscriptions;
    mapId: string;
    map: Leaflet__default.Map;
    polygonDraw: boolean;
    shapeLayer: any;
    geoJson: any;
    ngAfterViewInit(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private initDraw;
    private renderInitialShape;
    private clearShape;
    onDrawPolygon(): void;
    onDrawCircle(): void;
    onUndoStep(): void;
    onDeleteShape(): void;
    onChange: any;
    onTouched: any;
    writeValue(geoJson: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonDrawerInput, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PolygonDrawerInput, "adb-polygon-drawer", never, {}, {}, never, never, false, never>;
}

type GeoJsonGeometry = {
    type: "Point";
    coordinates: [number, number];
} | {
    type: "LineString";
    coordinates: [number, number][];
} | {
    type: "Polygon";
    coordinates: [number, number][][];
} | {
    type: "MultiPoint";
    coordinates: [number, number][];
} | {
    type: "MultiLineString";
    coordinates: [number, number][][];
} | {
    type: "MultiPolygon";
    coordinates: [number, number][][][];
} | {
    type: "GeometryCollection";
    geometries: GeoJsonGeometry[];
};
interface GeoJsonFeature {
    type: "Feature";
    geometry: GeoJsonGeometry;
    properties?: any;
}
interface MapOptions {
    providers?: boolean;
    zoom?: boolean;
    scrollZoom?: boolean;
}

declare class AdbMapFilters implements OnInit, OnDestroy {
    private cdr;
    private config;
    private http;
    private router;
    private activatedRoute;
    inline: boolean;
    static datasets: string[];
    subscriptions: Subscription;
    form: FormGroup;
    thisYear: Date;
    lastYear: Date;
    queryParamsMap: ParamMap;
    hasOwnArea: boolean;
    geo: GeoJsonFeature;
    area: {
        areaType: string;
        featureId: string;
    };
    areasArray: FormArray<any>;
    dataSetCount: number;
    taxonListCount: number;
    riskListCount: number;
    redListCount: number;
    areaCount: number;
    periodCount: number;
    listsError: any;
    filters: VisibleFilters;
    taxaLists: any[];
    hasTaxonInUrlParameter: any;
    dsControls: any;
    dateStartConfig: {
        maxDate: Date;
    };
    dateEndConfig: {
        minDate: Date;
        maxDate: Date;
    };
    artfakta: string;
    constructor(cdr: ChangeDetectorRef, config: AdbMapConfigService, http: HttpClient, router: Router, activatedRoute: ActivatedRoute);
    ngOnInit(): void;
    removeArea(index: number): void;
    addArea(): void;
    onSubmit(): void;
    private createForm;
    private updateCustomDate;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdbMapFilters, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdbMapFilters, "adb-map-filters", never, { "inline": { "alias": "inline"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TreeviewComponent implements ControlValueAccessor {
    nodes: ListItem[];
    private selectedIds;
    private onChange;
    private onTouched;
    writeValue(ids: number[] | null): void;
    registerOnChange(fn: (value: number[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onLeafToggle(node: ListItem): void;
    private applySelection;
    private setReadOnly;
    private static collectSelectedLeafIds;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeviewComponent, "app-treeview", never, { "nodes": { "alias": "nodes"; "required": false; }; }, {}, never, never, false, never>;
}
interface ListItem {
    id: number;
    name?: string;
    children?: ListItem[];
    _selected?: boolean;
    _readOnly?: boolean;
}

declare class AdbMapModule {
    static forRoot(config?: AdbMapConfig): ModuleWithProviders<AdbMapModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdbMapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbMapModule, [typeof AdbObsMapComponent, typeof PolygonDrawerInput, typeof AdbMapFilters, typeof TreeviewComponent], [typeof i5.CommonModule, typeof i6.FormsModule, typeof i7.RouterModule, typeof i6.ReactiveFormsModule, typeof i8.AdbDatePickerModule, typeof i9.TranslateModule, typeof i8.AdbPipesModule, typeof i8.AdbFilterSectionModule, typeof i8.AdbPickerModule], [typeof AdbObsMapComponent, typeof PolygonDrawerInput, typeof AdbMapFilters]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AdbMapModule>;
}

declare class AdbMapUtils {
    static readonly INITIAL_CENTER_LAT = 62;
    static readonly INITIAL_CENTER_LNG = 17;
    static OverlayMaps: {
        Altitude: any;
        Fjällkarta: any;
        Kommuner: any;
        Län: any;
        Ortnamn: any;
        'Ekonomisk zon': any;
    };
    static Providers: MapProvider[];
    static redListMapper2: {
        VU: string;
        EN: string;
        CR: string;
        RE: string;
        DD: string;
        NT: string;
    };
    static createMap(elementId: string, options?: MapOptions): Leaflet.Map;
    private static addProviders;
}
interface MapProvider {
    name: string;
    id: number;
    url: string;
    minZoom: number;
    maxZoom: number;
    wms: boolean;
    params?: any;
}

export { ADB_MAP_CONFIG, AdbMapConfigService, AdbMapFilterType, AdbMapFilters, AdbMapModule, AdbMapUtils, AdbObsMapComponent, PolygonDrawerInput, VisibleFilters };
export type { AdbMapConfig };