import * as i0 from '@angular/core';
import { OnInit, OnDestroy, EventEmitter, ElementRef, AfterViewInit, Renderer2, ModuleWithProviders, PipeTransform, ComponentRef, ViewContainerRef, ComponentFactoryResolver, RendererFactory2, ApplicationRef, Injector, TemplateRef, InjectionToken } 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 } from '@angular/router';
import * as i2 from '@angular/common';
import * as i4$1 from '@angular/forms';
import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';

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;
    label: string;
    id: string;
    constructor(el: ElementRef);
    private getTextarea;
    onDoubleClick(): void;
    onItalicClick(): void;
    onBoldClick(): void;
    private applyFormatting;
    private findWrappingMarker;
    onTaxonClick(): void;
    onReferenceClick(): void;
    private replaceMarked;
    onChange: (value: string) => void;
    onTouched: () => void;
    writeValue(value: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    onTextChange(): void;
    private updateValue;
    private getId;
    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; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, false, never>;
}

interface RichTextPart {
    type: 'text' | 'italic' | 'bold' | 'taxon' | 'term' | 'reference';
    content: string;
    id?: string;
}
declare class RichTextComponent {
    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 i4$1.FormsModule, typeof i4.TranslateModule], [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 i4$1.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: Event): 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: i0.WritableSignal<Area>;
    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: any | 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: i0.WritableSignal<Taxon>;
    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 i4$1.FormsModule, typeof i4.TranslateModule, typeof AdbPipesModule, typeof AdbDirectivesModule], [typeof GenericPickerComponent, typeof AdbAreaPickerComponent, typeof AdbTaxonPickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AdbPickerModule>;
}

export { ADB_PICKER_CONFIG, ADB_USER_SERVICE_CONFIG, AdbAreaPickerComponent, AdbButtonsModule, AdbConfirmModal, AdbDatePickerComponent, AdbDatePickerDirective, AdbDatePickerModule, AdbDirectivesModule, AdbDropdown2Directive, AdbDropdownDirective, AdbDropdownModule, AdbFilterSectionModule, AdbHelpButtonComponent, AdbModalModule, AdbModalService, 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, RedListBadgeClassDirective, RichTextComponent, RiskClassDirective, RouterLinkActiveFragmentDirective, ToastType, UserModuleConstants };
export type { AdbPickerConfig, AdbUserServiceConfig, DialogModel, PickerDay, PickerWeek, RichTextPart, ToastMessage };