adb-shared 6.1.10 → 6.2.0-beta.1

package/types/adb-shared.d.ts

@@ -0,0 +1,1102 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ElementRef, AfterViewInit, Renderer2, ModuleWithProviders, PipeTransform, ComponentRef, ViewContainerRef, ComponentFactoryResolver, RendererFactory2, ApplicationRef, Injector, TemplateRef, InjectionToken, ChangeDetectorRef } from '@angular/core';
+import * as i4 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as i5 from '@angular/router';
+import { Router, ActivatedRoute, ParamMap } from '@angular/router';
+import * as i2 from '@angular/common';
+import * as i6 from '@angular/forms';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, FormGroup, FormArray } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
+import * as Leaflet from 'leaflet';
+
+interface Navigation {
+    home: Link2;
+    report: Link2;
+    wanted: Link2;
+    checklist: Link2;
+    createAccountLink: Link2;
+    observations: Link2;
+    fieldDiary: Link2;
+    subcriptions: Link2;
+    events: Link2;
+    fyndregler: Link2;
+    artportalenUrl: string;
+    artfaktaUrl: string;
+}
+interface Link2 {
+    transId: string;
+    url: string;
+}
+
+declare class EnvironmentService {
+    environment: any;
+    constructor(environment: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnvironmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnvironmentService>;
+}
+
+declare class ArtportalenNavComponent implements OnInit, OnDestroy {
+    private httpClient;
+    private router;
+    trans: TranslateService;
+    private envService;
+    private subscription;
+    loginClicked: EventEmitter<any>;
+    logoutClicked: EventEmitter<any>;
+    dropMenuChange: EventEmitter<boolean>;
+    showPattern: boolean;
+    fullName: string;
+    translationFinished: boolean;
+    lastPosition: number;
+    set userName(fullName: string);
+    navigation: Navigation;
+    url: string;
+    showNavMenu: boolean;
+    showUserMenu: boolean;
+    showReport: boolean;
+    showObservations: boolean;
+    showSubs: boolean;
+    constructor(httpClient: HttpClient, router: Router, trans: TranslateService, envService: EnvironmentService);
+    ngOnInit(): void;
+    showMenuDropdown(show: boolean): void;
+    setLanguage(lang: any): void;
+    onUserClick(): void;
+    login(): void;
+    logout(): void;
+    private initTranslations;
+    private loadTranslation;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArtportalenNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArtportalenNavComponent, "adb-artportalen-nav", never, { "showPattern": { "alias": "showPattern"; "required": false; }; "userName": { "alias": "userName"; "required": false; }; }, { "loginClicked": "loginClicked"; "logoutClicked": "logoutClicked"; "dropMenuChange": "dropMenuChange"; }, never, ["*"], false, never>;
+}
+
+declare class ArtportalenFooterComponent implements OnInit, OnDestroy {
+    private httpClient;
+    private envService;
+    trans: TranslateService;
+    private subscription;
+    translationFinished: boolean;
+    url: string;
+    navigation: Navigation;
+    baseUrl: any;
+    constructor(httpClient: HttpClient, envService: EnvironmentService, trans: TranslateService);
+    ngOnInit(): void;
+    private initTranslations;
+    private loadTranslation;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArtportalenFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArtportalenFooterComponent, "adb-artportalen-footer", never, {}, {}, never, never, false, never>;
+}
+
+declare class ClickOutsideDirective {
+    private elementRef;
+    adbClickOutside: EventEmitter<any>;
+    constructor(elementRef: ElementRef);
+    onClick(target: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[adbClickOutside]", never, {}, { "adbClickOutside": "adbClickOutside"; }, never, never, false, never>;
+}
+
+declare class FocusDirective implements AfterViewInit {
+    element: ElementRef<HTMLElement>;
+    focused: boolean;
+    set adbFocus(value: boolean);
+    constructor(element: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusDirective, "[adbFocus]", never, { "adbFocus": { "alias": "adbFocus"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FileUploadDirective {
+    private el;
+    upload: EventEmitter<any>;
+    click: EventEmitter<any>;
+    constructor(el: ElementRef);
+    onBeginUpload(target: any): void;
+    onClick(target: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileUploadDirective, "input[adbFileUpload]", never, {}, { "upload": "upload"; }, never, never, false, never>;
+}
+
+declare class RedListBadgeClassDirective {
+    redlistId: string;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RedListBadgeClassDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RedListBadgeClassDirective, "[adbRedListBadgeClass]", never, { "redlistId": { "alias": "adbRedListBadgeClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RiskClassDirective {
+    category: string;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RiskClassDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RiskClassDirective, "[adbRiskClass]", never, { "category": { "alias": "adbRiskClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ImageLoaderDirective implements OnDestroy {
+    private el;
+    private renderer;
+    private translate;
+    private _fallbackKey;
+    set fallbackKey(value: string | undefined);
+    get fallbackKey(): string;
+    private translationSub?;
+    private spinnerElement?;
+    constructor(el: ElementRef, renderer: Renderer2, translate: TranslateService);
+    private showSpinner;
+    private hideSpinner;
+    onLoad(): void;
+    onError(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLoaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageLoaderDirective, "img[adbImageLoader]", never, { "fallbackKey": { "alias": "adbImageLoader"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RouterLinkActiveFragmentDirective implements OnInit, OnDestroy {
+    private router;
+    private el;
+    private renderer;
+    activeClass: string;
+    fragment: string | null;
+    private sub;
+    constructor(router: Router, el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    private updateActiveState;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkActiveFragmentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RouterLinkActiveFragmentDirective, "[adbActiveFragment]", never, { "activeClass": { "alias": "adbActiveFragment"; "required": false; }; "fragment": { "alias": "fragment"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AdbDirectivesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDirectivesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbDirectivesModule, [typeof ClickOutsideDirective, typeof FocusDirective, typeof FileUploadDirective, typeof RedListBadgeClassDirective, typeof RiskClassDirective, typeof ImageLoaderDirective, typeof RouterLinkActiveFragmentDirective], never, [typeof ClickOutsideDirective, typeof FocusDirective, typeof FileUploadDirective, typeof RedListBadgeClassDirective, typeof RiskClassDirective, typeof ImageLoaderDirective, typeof RouterLinkActiveFragmentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbDirectivesModule>;
+}
+
+declare class AdbDropdownService {
+    currentMenu: any;
+    currentMenuId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDropdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbDropdownService>;
+}
+
+declare class AdbDropdownDirective {
+    private elementRef;
+    private adbDropdownService;
+    constructor(elementRef: ElementRef, adbDropdownService: AdbDropdownService);
+    adbDropdown: EventEmitter<any>;
+    insideClick: boolean;
+    id: string;
+    dataToggle: string;
+    haspPopup: boolean;
+    expanded: boolean;
+    dropId: string;
+    onClick(): void;
+    onCheckOutSideClick(target: any): void;
+    close(): void;
+    private getId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AdbDropdownDirective, "[adbDropdown]", ["adbDropdown"], { "insideClick": { "alias": "insideClick"; "required": false; }; }, { "adbDropdown": "adbDropdown"; }, never, never, false, never>;
+}
+
+declare class AdbDropdown2Directive {
+    private elementRef;
+    private adbDropdownService;
+    constructor(elementRef: ElementRef, adbDropdownService: AdbDropdownService);
+    adbDropdown: EventEmitter<any>;
+    insideClick: boolean;
+    id: string;
+    dataToggle: string;
+    haspPopup: boolean;
+    expanded: boolean;
+    dropId: string;
+    onClick(): void;
+    onCheckOutSideClick(target: any): void;
+    onWindowScroll(): void;
+    private setMenuPosition;
+    close(): void;
+    private getId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDropdown2Directive, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AdbDropdown2Directive, "[adbDropdown2]", ["adbDropdown"], { "insideClick": { "alias": "insideClick"; "required": false; }; }, { "adbDropdown": "adbDropdown"; }, never, never, false, never>;
+}
+
+declare class AdbDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbDropdownModule, [typeof AdbDropdownDirective, typeof AdbDropdown2Directive], [typeof i2.CommonModule, typeof i4.TranslateModule, typeof AdbDirectivesModule], [typeof AdbDropdownDirective, typeof AdbDropdown2Directive]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbDropdownModule>;
+}
+
+declare class InfiniteScrollComponent implements AfterViewInit, OnDestroy {
+    private _element;
+    onVisible: EventEmitter<any>;
+    onHidden: EventEmitter<any>;
+    height: string;
+    private _intersectionObserver?;
+    constructor(_element: ElementRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private checkForIntersection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteScrollComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfiniteScrollComponent, "[onVisible]", never, {}, { "onVisible": "onVisible"; "onHidden": "onHidden"; }, never, never, false, never>;
+}
+
+declare abstract class PagerBaseDirective {
+    private static DEFAULT_LIMIT;
+    private static VISIBLE_PAGES;
+    protected static SKIP_RESOURCE: string;
+    limit: number;
+    totalCount: number;
+    set setTotalCount(count: number);
+    set setLimit(value: number);
+    pages: Array<number>;
+    amountOfPages: number;
+    currentPage: number;
+    protected calculatePages(): void;
+    protected abstract ngOnInitReady(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagerBaseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PagerBaseDirective, never, never, { "setTotalCount": { "alias": "totalCount"; "required": false; }; "setLimit": { "alias": "limit"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PagerComponent extends PagerBaseDirective implements OnDestroy {
+    private activatedRoute;
+    private subscription;
+    offsetName: string;
+    infiniteLimit: boolean;
+    params: {
+        first: any;
+        prev: any;
+        pages?: any[];
+        next: any;
+        last: any;
+    };
+    constructor(activatedRoute: ActivatedRoute);
+    ngOnInitReady(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PagerComponent, "adb-pager-nav", never, { "offsetName": { "alias": "offsetName"; "required": false; }; "infiniteLimit": { "alias": "infiniteLimit"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class PagerInlineComponent extends PagerBaseDirective {
+    pageChanged: EventEmitter<number>;
+    infiniteLimit: boolean;
+    constructor();
+    ngOnInitReady(): void;
+    onFirstClick(): void;
+    onPrevClick(): void;
+    onPageClick(page: number): void;
+    onNextClick(): void;
+    onLastClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagerInlineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PagerInlineComponent, "adb-pager", never, { "infiniteLimit": { "alias": "infiniteLimit"; "required": false; }; }, { "pageChanged": "pageChanged"; }, never, never, false, never>;
+}
+
+declare class AdbPagersModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbPagersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbPagersModule, [typeof InfiniteScrollComponent, typeof PagerComponent, typeof PagerInlineComponent], [typeof i2.CommonModule, typeof i5.RouterModule], [typeof InfiniteScrollComponent, typeof PagerComponent, typeof PagerInlineComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbPagersModule>;
+}
+
+declare class ArtportalenNavModule {
+    static forRoot(environment: any): ModuleWithProviders<ArtportalenNavModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArtportalenNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArtportalenNavModule, [typeof ArtportalenNavComponent, typeof ArtportalenFooterComponent], [typeof i2.CommonModule, typeof i5.RouterModule, typeof i4.TranslateModule, typeof AdbDirectivesModule, typeof AdbDropdownModule, typeof AdbPagersModule], [typeof ArtportalenNavComponent, typeof ArtportalenFooterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArtportalenNavModule>;
+}
+
+declare class HighlightPipe implements PipeTransform {
+    forbiddenSymbols: RegExp;
+    transform(value: any, searchs: any): any;
+    private normalizeText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightPipe, "adbHighlight", false>;
+}
+
+declare class HighlightHtmlPipe implements PipeTransform {
+    forbiddenSymbols: RegExp;
+    transform(value: any, searchs: any): any;
+    private normalizeText;
+    private escapeRegExp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightHtmlPipe, "adbHighlightHtml", false>;
+}
+
+declare class NumberSpacingPipe implements PipeTransform {
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberSpacingPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberSpacingPipe, "adbSpacing", false>;
+}
+
+declare class LocaleDatePipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslateService);
+    transform(value: any, format: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocaleDatePipe, "adbLocaleDate", false>;
+}
+
+declare class EmptyValuePipe implements PipeTransform {
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EmptyValuePipe, "adbEmptyValue", false>;
+}
+
+declare class AdbPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbPipesModule, [typeof HighlightPipe, typeof HighlightHtmlPipe, typeof NumberSpacingPipe, typeof LocaleDatePipe, typeof EmptyValuePipe], never, [typeof HighlightPipe, typeof HighlightHtmlPipe, typeof NumberSpacingPipe, typeof LocaleDatePipe, typeof EmptyValuePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbPipesModule>;
+}
+
+declare class AdbDatePickerComponent implements OnInit, OnDestroy {
+    elementRef: ElementRef;
+    private translate;
+    private subscriptions;
+    static MONTHS: number[];
+    static WEEK_DAYS: string[];
+    static YEAR_INTERVALL: number;
+    currentdDate: Date;
+    currentMonth: number;
+    selectedDate: Date;
+    years: {
+        value: Date;
+        title: string;
+        isThisYear: boolean;
+    }[];
+    months: {
+        value: number;
+        isThisMonth: boolean;
+    }[];
+    weekDays: string[];
+    weeks: PickerWeek[];
+    range: {
+        start: any;
+        end: any;
+    };
+    noYearMode: boolean;
+    initialDate: Date;
+    settings: any;
+    toLeft: boolean;
+    id: string;
+    selectDate: EventEmitter<Date>;
+    constructor(elementRef: ElementRef, translate: TranslateService);
+    ngOnInit(): void;
+    onShowYear(): void;
+    onShowMonth(): void;
+    onSelectYear(inYear?: Date): void;
+    onSelectMonth(inMonth?: number): void;
+    onPrev(): void;
+    onNext(): void;
+    ngOnDestroy(): void;
+    private loadMonths;
+    private loadYearsInterval;
+    onSelectDate(day: PickerDay): void;
+    private createCalendar;
+    static parseDate(value: Date | string): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbDatePickerComponent, "adb-date-picker", never, { "initialDate": { "alias": "initialDate"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "toLeft": { "alias": "toLeft"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "selectDate": "selectDate"; }, never, never, false, never>;
+}
+interface PickerWeek {
+    weeks: {
+        weekNumber: number;
+        days: PickerDay[];
+    }[];
+}
+interface PickerDay {
+    value: Date;
+    isToday: boolean;
+    isInRange: boolean;
+    inMonth: boolean;
+    isSelected: boolean;
+}
+
+declare class AdbDatePickerService {
+    viewRef: ComponentRef<AdbDatePickerComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDatePickerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbDatePickerService>;
+}
+
+declare class AdbDatePickerDirective implements ControlValueAccessor, Validator, OnInit, OnDestroy {
+    private viewContainerRef;
+    private renderer;
+    private elementRef;
+    private adbDatePickerService;
+    translate: TranslateService;
+    private subscriptions;
+    autocomplete: string;
+    adbBlur: EventEmitter<Date>;
+    format: string;
+    toLeft: boolean;
+    settings: {
+        maxDate?: Date | string;
+        minDate?: Date | string;
+    };
+    id: string;
+    currentDate: Date;
+    isValid: boolean;
+    constructor(viewContainerRef: ViewContainerRef, renderer: Renderer2, elementRef: ElementRef, adbDatePickerService: AdbDatePickerService, translate: TranslateService);
+    ngOnInit(): void;
+    onClick(): void;
+    onKeyup(event: KeyboardEvent): void;
+    onTabDown(): void;
+    onEscdOWN(): void;
+    onHide(): void;
+    onCheckOutSideClick(target: any): void;
+    private updateValueOnLeave;
+    ngOnDestroy(): void;
+    validate(control: AbstractControl): ValidationErrors;
+    onChange: any;
+    onTouched: any;
+    onValidationChange: any;
+    registerOnValidatorChange?(fn: () => void): void;
+    writeValue(value: Date | string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static tryParse(dateString: string): Date;
+    private getId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDatePickerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AdbDatePickerDirective, "input[adbDatepicker]", never, { "format": { "alias": "format"; "required": false; }; "toLeft": { "alias": "toLeft"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; }, { "adbBlur": "adbBlur"; }, never, never, false, never>;
+}
+
+declare class AdbDatePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbDatePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbDatePickerModule, [typeof AdbDatePickerComponent, typeof AdbDatePickerDirective], [typeof i2.CommonModule, typeof i4.TranslateModule, typeof AdbPipesModule, typeof AdbDirectivesModule], [typeof AdbDatePickerComponent, typeof AdbDatePickerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbDatePickerModule>;
+}
+
+declare class AdbModalService {
+    private componentFactoryResolver;
+    private appRef;
+    private injector;
+    private closeSubject;
+    close$: rxjs.Observable<boolean>;
+    renderer: Renderer2;
+    domElem: HTMLElement;
+    backdrop: any;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, rendererFactory: RendererFactory2, appRef: ApplicationRef, injector: Injector);
+    hide(confirm: boolean): void;
+    showConfirm(model: DialogModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbModalService>;
+}
+
+declare class AdbConfirmModal implements AfterViewInit {
+    modalRef: AdbModalService;
+    private elementRef;
+    model: DialogModel;
+    constructor(modalRef: AdbModalService, elementRef: ElementRef);
+    ngAfterViewInit(): void;
+    onClose(confirm: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbConfirmModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbConfirmModal, "ng-component", never, { "model": { "alias": "model"; "required": false; }; }, {}, never, never, false, never>;
+}
+interface DialogModel {
+    header: string;
+    text: string;
+    confirm?: string;
+    decline?: string;
+    showDecline?: boolean;
+    value?: any;
+}
+
+declare class AdbModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbModalModule, [typeof AdbConfirmModal], [typeof i2.CommonModule, typeof i4.TranslateModule, typeof AdbDirectivesModule], [typeof AdbConfirmModal]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbModalModule>;
+}
+
+declare class AdbToastService {
+    private componentFactoryResolver;
+    private rendererFactory;
+    private appRef;
+    private injector;
+    private toasts;
+    private toastsSubject;
+    $toasts: Observable<ToastMessage[]>;
+    renderer: Renderer2;
+    domElement: HTMLElement;
+    container: any;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, rendererFactory: RendererFactory2, appRef: ApplicationRef, injector: Injector);
+    add(toastMessage: ToastMessage, time?: number): void;
+    remove(toast: ToastMessage): void;
+    private addContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbToastService>;
+}
+interface ToastMessage {
+    header?: string;
+    headerValue?: any;
+    message: string;
+    messageValue?: any;
+    type?: ToastType;
+    index?: number;
+    delay?: any;
+}
+declare enum ToastType {
+    Primary = 1,
+    Success = 2,
+    Warn = 3,
+    Danger = 4
+}
+
+declare class AdbToast {
+    toastService: AdbToastService;
+    toasts: ToastMessage[];
+    toastType: typeof ToastType;
+    constructor(toastService: AdbToastService);
+    onRemoveToast(toast: ToastMessage): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbToast, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbToast, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class AdbToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbToastModule, [typeof AdbToast], [typeof i2.CommonModule, typeof i4.TranslateModule, typeof AdbDirectivesModule], [typeof AdbToast]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbToastModule>;
+}
+
+declare class AdbHelpButtonComponent implements OnInit {
+    private elementRef;
+    showHelp: boolean;
+    buttonClass: string;
+    iconClass: string;
+    label: string;
+    id: number;
+    onClickDoc(event: MouseEvent): void;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbHelpButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbHelpButtonComponent, "adb-help-button", never, { "buttonClass": { "alias": "buttonClass"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class AdbButtonsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbButtonsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbButtonsModule, [typeof AdbHelpButtonComponent], [typeof i2.CommonModule, typeof AdbDirectivesModule], [typeof AdbHelpButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbButtonsModule>;
+}
+
+interface RichModuleConfig {
+    taxonUrl: string;
+}
+
+declare class AdbRichEditorComponent implements ControlValueAccessor, OnDestroy {
+    private el;
+    text: string;
+    hasTaxon: boolean;
+    hasReference: boolean;
+    rows: number;
+    constructor(el: ElementRef);
+    onDoubleClick(): void;
+    onItalicClick(): void;
+    onBoldClick(): void;
+    private applyFormatting;
+    onTaxonClick(): void;
+    onReferenceClick(): void;
+    private replaceMarked;
+    onTextChange(): void;
+    onChange: any;
+    onTouched: any;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbRichEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbRichEditorComponent, "adb-rich-editor", never, { "hasTaxon": { "alias": "hasTaxon"; "required": false; }; "hasReference": { "alias": "hasReference"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface RichTextPart {
+    type: 'text' | 'italic' | 'bold' | 'taxon' | 'term' | 'reference';
+    content: string;
+    id?: string;
+}
+declare class RichTextComponent {
+    private config;
+    text: string;
+    parts: RichTextPart[];
+    taxonUrl: string;
+    constructor(config: RichModuleConfig);
+    ngOnChanges(): void;
+    private parseCustomMarkdown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RichTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RichTextComponent, "adb-rich-text", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AdbRichEditorModule {
+    static forRoot(config: RichModuleConfig): ModuleWithProviders<AdbRichEditorModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbRichEditorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbRichEditorModule, [typeof AdbRichEditorComponent, typeof RichTextComponent], [typeof i2.CommonModule, typeof i6.FormsModule], [typeof AdbRichEditorComponent, typeof RichTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbRichEditorModule>;
+}
+
+declare class FilterSectionComponent implements OnInit, OnDestroy {
+    titleResource: string;
+    helpResource: any;
+    count: number;
+    expanded: any;
+    lazy: boolean;
+    id: number;
+    template?: TemplateRef<unknown>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSectionComponent, "adb-filter-section", never, { "titleResource": { "alias": "titleResource"; "required": false; }; "helpResource": { "alias": "helpResource"; "required": false; }; "count": { "alias": "count"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "lazy": { "alias": "lazy"; "required": false; }; }, {}, ["template"], ["*"], false, never>;
+}
+
+declare class AdbFilterSectionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbFilterSectionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbFilterSectionModule, [typeof FilterSectionComponent], [typeof i2.CommonModule, typeof i6.FormsModule, typeof i4.TranslateModule, typeof AdbButtonsModule], [typeof FilterSectionComponent, typeof AdbButtonsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbFilterSectionModule>;
+}
+
+interface AdbUserServiceConfig {
+    redirectUrl: string;
+    clientId: string;
+    issuer: string;
+    scope?: string;
+    responseType?: string;
+    idleTime?: number;
+    autoLogin?: boolean;
+    postLogoutUrl?: string;
+    overrideIssuer?: boolean;
+    log?: boolean;
+}
+declare const ADB_USER_SERVICE_CONFIG: InjectionToken<AdbUserServiceConfig>;
+declare const DEFAULT_ADB_USER_SERVICE_CONFIG: {
+    scope: string;
+    idleTime: number;
+    autoLogin: boolean;
+    response_type: string;
+    overrideIssuer: boolean;
+    log: boolean;
+};
+
+declare class AdbUserService implements OnDestroy {
+    config: AdbUserServiceConfig;
+    private http;
+    private router;
+    private subscriptions;
+    private userSubject;
+    user$: rxjs.Observable<any>;
+    lastRefreshTime: number;
+    intervalId: any;
+    constructor(config: AdbUserServiceConfig, http: HttpClient, router: Router);
+    init(): void;
+    startMainLoop(): void;
+    login(url?: string): void;
+    logout(): void;
+    private checkStatus;
+    _internalTriggerUserEvent(token: string): void;
+    private refreshToken;
+    setTokensInSession(params: any): void;
+    authorize(): Promise<void>;
+    private addQueryParams;
+    private getTokenTimeToLive;
+    private canRefreshToken;
+    private hasUserBeenActive;
+    log(message: string, ...optionalParams: any[]): void;
+    getUser(token: string): any;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbUserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbUserService>;
+}
+
+declare class AuthCallbackComponent implements OnInit {
+    private activatedRoute;
+    private router;
+    private http;
+    private adbUserService;
+    private subscriptions;
+    constructor(activatedRoute: ActivatedRoute, router: Router, http: HttpClient, adbUserService: AdbUserService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthCallbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AuthCallbackComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class AdbUserModule {
+    static forRoot(config?: AdbUserServiceConfig): ModuleWithProviders<AdbUserModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbUserModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbUserModule, [typeof AuthCallbackComponent], [typeof i2.CommonModule, typeof i5.RouterModule, typeof i4.TranslateModule], [typeof AuthCallbackComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbUserModule>;
+}
+
+declare class AdbUserInterceptor implements HttpInterceptor {
+    private adbUserService;
+    private static UNAUTHENTICATED;
+    constructor(adbUserService: AdbUserService);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    private handleErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbUserInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbUserInterceptor>;
+}
+
+declare class UserModuleConstants {
+    static CURRENT_URL: string;
+    static CODE_VERIFIER: string;
+    static REFRESH_TOKEN: string;
+    static TOKEN_EXPIRES: string;
+    static ACCESS_TOKEN: string;
+    static USER_LAST_ACTIVE: string;
+    static ONGOING_CODEFLOW: string;
+}
+
+interface AdbPickerConfig {
+    api: string;
+}
+declare const ADB_PICKER_CONFIG: InjectionToken<AdbPickerConfig>;
+declare class AdbPickerConfigService {
+    readonly areas: string;
+    readonly taxa: string;
+    constructor(config: AdbPickerConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbPickerConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbPickerConfigService>;
+}
+
+interface SOSArea {
+    name: string;
+    areaType: string;
+    featureId: string;
+}
+interface Area {
+    id: string;
+    name: string;
+    areaType: string;
+    featureId: string;
+}
+interface PagedResult<T> {
+    records: Array<T>;
+    items?: Array<T>;
+    totalCount: number;
+}
+interface Taxon {
+    id: any;
+    swedishName: string;
+    scientificName: string;
+}
+
+declare class GenericPickerComponent<T> implements OnInit, OnDestroy {
+    private readonly subs;
+    private readonly searchChanged$;
+    search: (query: string) => Observable<PagedResult<T>>;
+    displayFn: (item: T) => string;
+    loadById?: (id: any) => Observable<T>;
+    disabled: boolean;
+    placeholder: string;
+    itemTemplate: TemplateRef<any>;
+    selectItemChange: EventEmitter<T>;
+    focus: EventEmitter<FocusEvent>;
+    set initialValue(item: T | null);
+    searchQuery: string;
+    loading: boolean;
+    error: any;
+    items$: Observable<T[]>;
+    private itemsSnapshot;
+    showPop: boolean;
+    rowIndex: number;
+    ngOnInit(): void;
+    onModelChange(): void;
+    onArrowDown(): void;
+    onArrowUp(): void;
+    onEnter(event: KeyboardEvent): void;
+    resetPopup(): void;
+    selectItem(item: T | null): void;
+    resetModel(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GenericPickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GenericPickerComponent<any>, "adb-generic-picker", never, { "search": { "alias": "search"; "required": false; }; "displayFn": { "alias": "displayFn"; "required": false; }; "loadById": { "alias": "loadById"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; }, { "selectItemChange": "selectItemChange"; "focus": "focus"; }, ["itemTemplate"], never, false, never>;
+}
+
+declare class AdbAreaPickerComponent implements ControlValueAccessor {
+    private translate;
+    private config;
+    private http;
+    fullWidth: boolean;
+    placeholder: string;
+    useObject: boolean;
+    prefill: boolean;
+    initialValue: Area | null;
+    isDisabled: boolean;
+    loading: boolean;
+    showPrefill: boolean;
+    private onChange;
+    private onTouched;
+    constructor(translate: TranslateService, config: AdbPickerConfigService, http: HttpClient);
+    getAreas: (query: string) => rxjs.Observable<PagedResult<Area>>;
+    displayArea: (area: SOSArea) => string;
+    loadAreaId: (id: any) => rxjs.Observable<Area>;
+    onSelect(area: Area | null): void;
+    onFocus(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbAreaPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbAreaPickerComponent, "adb-area-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "useObject": { "alias": "useObject"; "required": false; }; "prefill": { "alias": "prefill"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class AdbTaxonPickerComponent implements ControlValueAccessor {
+    private config;
+    private http;
+    fullWidth: boolean;
+    placeholder: string;
+    useObject: boolean;
+    prefill: boolean;
+    initialValue: Taxon | null;
+    isDisabled: boolean;
+    loading: boolean;
+    showPrefill: boolean;
+    private onChange;
+    private onTouched;
+    constructor(config: AdbPickerConfigService, http: HttpClient);
+    getTaxa: (query: string) => rxjs.Observable<{
+        items: Taxon[];
+    } | {
+        items: any[];
+    }>;
+    displayTaxon: (taxon: Taxon) => string;
+    loadTaxonById(id: any): rxjs.Observable<Taxon>;
+    onSelect(taxon: Taxon | null): void;
+    onFocus(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbTaxonPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbTaxonPickerComponent, "adb-taxon-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "useObject": { "alias": "useObject"; "required": false; }; "prefill": { "alias": "prefill"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class AdbPickerModule {
+    static forRoot(config?: AdbPickerConfig): ModuleWithProviders<AdbPickerModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AdbPickerModule, [typeof GenericPickerComponent, typeof AdbAreaPickerComponent, typeof AdbTaxonPickerComponent], [typeof i2.CommonModule, typeof i6.FormsModule, typeof i4.TranslateModule, typeof AdbPipesModule, typeof AdbDirectivesModule], [typeof GenericPickerComponent, typeof AdbAreaPickerComponent, typeof AdbTaxonPickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbPickerModule>;
+}
+
+interface AdbMapConfig {
+    api: string;
+    artfaktaTaxonLists: string;
+    artportalen: string;
+    filters?: AdbMapFilterType[];
+    log?: boolean;
+}
+declare enum AdbMapFilterType {
+    Taxon = "taxon",
+    Area = "area",
+    Time = "time",
+    RedList = "redlist",
+    RiskList = "risklist",
+    TaxaLists = "taxonLists",
+    Datasources = "datasources"
+}
+declare class VisibleFilters {
+    showTaxon: boolean;
+    showTime: boolean;
+    showArea: boolean;
+    showRedList: boolean;
+    showRiskList: boolean;
+    showTaxaLists: boolean;
+    showDatasets: boolean;
+}
+declare const ADB_MAP_CONFIG: InjectionToken<AdbMapConfig>;
+declare class AdbMapConfigService {
+    readonly log: boolean;
+    readonly artfaktaTaxonLists: string;
+    readonly aportalenObservations: string;
+    readonly taxaListsApi: string;
+    readonly filters: VisibleFilters;
+    constructor(config: AdbMapConfig);
+    private hasFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbMapConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdbMapConfigService>;
+}
+
+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 AdbBaseMap implements AfterViewInit {
+    subscriptions: Subscription;
+    mapId: string;
+    map: any;
+    tileLayer: Leaflet.tileLayer;
+    protected INITIAL_CENTER_LAT: number;
+    protected INITIAL_CENTER_LNG: number;
+    hasProviders: boolean;
+    hasZoom: boolean;
+    hasScrollZoom: boolean;
+    private mapReadySubject;
+    readonly mapReady$: rxjs.Observable<boolean>;
+    private mapMoveSubject;
+    readonly mapMove$: rxjs.Observable<void>;
+    constructor(options?: MapOptions);
+    getId(): string;
+    ngAfterViewInit(): void;
+    addMapLayers(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbBaseMap, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AdbBaseMap, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class AdbObsMapComponent extends AdbBaseMap implements OnInit, OnDestroy {
+    private activatedRoute;
+    private config;
+    private router;
+    private http;
+    error: null;
+    loading: boolean;
+    siteLayer: Leaflet.FeatureGroup;
+    hasBox: boolean;
+    count: any;
+    aportalenObservations: string;
+    constructor(activatedRoute: ActivatedRoute, config: AdbMapConfigService, router: Router, http: HttpClient);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadFeature;
+    private buildMap;
+    private getPolygonClassName;
+    private getMapBoundsToBbox;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdbObsMapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdbObsMapComponent, "adb-obs-map", never, {}, {}, never, never, false, never>;
+}
+
+declare class PolygonDrawerInput extends AdbBaseMap implements ControlValueAccessor, OnInit, OnDestroy {
+    drawControl: any;
+    polygonDrawer: any;
+    polygonDraw: boolean;
+    shapeLayer: any;
+    drawLayer: any;
+    geoJson: any;
+    ngOnInit(): void;
+    constructor();
+    onDrawPolygon(): void;
+    onDeleteShape(): void;
+    onUndoStep(): void;
+    onMapMoveEnd(): void;
+    onChange: any;
+    onTouched: any;
+    writeValue(geoJson: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PolygonDrawerInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PolygonDrawerInput, "adb-polygon-drawer", never, {}, {}, never, never, false, never>;
+}
+
+declare class AdbMapFilters implements OnInit, OnDestroy {
+    private cdr;
+    private config;
+    private http;
+    private router;
+    private activatedRoute;
+    inline: boolean;
+    private static AlienSpecies;
+    private static Risklist;
+    private static Redlist;
+    static datasets: string[];
+    artfakta: string;
+    subscriptions: Subscription;
+    form: FormGroup;
+    thisYear: Date;
+    lastYear: Date;
+    dateConfig: {
+        minDate: any;
+        maxDate: 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;
+    rcControls: any;
+    rlcControls: any;
+    dsControls: any;
+    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;
+    private getLists;
+    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 i2.CommonModule, typeof i6.FormsModule, typeof i5.RouterModule, typeof i6.ReactiveFormsModule, typeof AdbDatePickerModule, typeof i4.TranslateModule, typeof AdbPipesModule, typeof AdbFilterSectionModule, typeof AdbPickerModule], [typeof AdbObsMapComponent, typeof PolygonDrawerInput, typeof AdbMapFilters]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AdbMapModule>;
+}
+
+export { ADB_MAP_CONFIG, ADB_PICKER_CONFIG, ADB_USER_SERVICE_CONFIG, AdbAreaPickerComponent, AdbBaseMap, AdbButtonsModule, AdbConfirmModal, AdbDatePickerComponent, AdbDatePickerDirective, AdbDatePickerModule, AdbDirectivesModule, AdbDropdown2Directive, AdbDropdownDirective, AdbDropdownModule, AdbFilterSectionModule, AdbHelpButtonComponent, AdbMapConfigService, AdbMapFilterType, AdbMapFilters, AdbMapModule, AdbModalModule, AdbModalService, AdbObsMapComponent, AdbPagersModule, AdbPickerConfigService, AdbPickerModule, AdbPipesModule, AdbRichEditorComponent, AdbRichEditorModule, AdbTaxonPickerComponent, AdbToast, AdbToastModule, AdbToastService, AdbUserInterceptor, AdbUserModule, AdbUserService, ArtportalenFooterComponent, ArtportalenNavComponent, ArtportalenNavModule, AuthCallbackComponent, ClickOutsideDirective, DEFAULT_ADB_USER_SERVICE_CONFIG, EmptyValuePipe, EnvironmentService, FileUploadDirective, FilterSectionComponent, FocusDirective, GenericPickerComponent, HighlightHtmlPipe, HighlightPipe, ImageLoaderDirective, InfiniteScrollComponent, LocaleDatePipe, NumberSpacingPipe, PagerComponent, PagerInlineComponent, PolygonDrawerInput, RedListBadgeClassDirective, RichTextComponent, RiskClassDirective, RouterLinkActiveFragmentDirective, ToastType, UserModuleConstants, VisibleFilters };
+export type { AdbMapConfig, AdbPickerConfig, AdbUserServiceConfig, DialogModel, PickerDay, PickerWeek, RichTextPart, ToastMessage };