import * as i0 from '@angular/core';
import { PipeTransform, OnChanges, OnInit, AfterViewInit, EventEmitter, Renderer2, SimpleChanges, ElementRef, AfterViewChecked, AfterContentInit, OnDestroy, QueryList, ChangeDetectorRef, Injector } from '@angular/core';
import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
import { AnimationEvent } from '@angular/animations';
import * as rxjs from 'rxjs';
import { Observable, Subject, Subscription } from 'rxjs';
import * as i94 from '@angular/forms';
import { ControlValueAccessor, AbstractControl, ControlContainer, NgControl } from '@angular/forms';
import * as i95 from '@angular/router';
import { Router } from '@angular/router';
import * as i96 from 'ngx-scrollbar';
import { NgScrollbar } from 'ngx-scrollbar';
import * as i97 from '@angular/common';
import * as i1 from '@fortawesome/angular-fontawesome';
import { FaIconLibrary } from '@fortawesome/angular-fontawesome';

declare class SafePipe implements PipeTransform {
    private sanitizer;
    constructor(sanitizer: DomSanitizer);
    transform(url: string): SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", false>;
}

declare class TruncatePipe implements PipeTransform {
    transform(value: string, maxLength?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", false>;
}

declare class FilterPipe implements PipeTransform {
    transform(valueList: any[], filter: string, properties?: string[]): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filterByProperties", false>;
}

declare class ErrorMessagePipe implements PipeTransform {
    currentMessage: string;
    transform(message: any, errors: any, label: any, small?: boolean): string;
    private setErrorMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessagePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ErrorMessagePipe, "errorMessage", false>;
}

declare class HsaidPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HsaidPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HsaidPipe, "hsaidPipe", false>;
}

declare class PersonnummerPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersonnummerPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PersonnummerPipe, "personnummer", false>;
}

declare class PostnummerPipe implements PipeTransform {
    transform(value: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PostnummerPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PostnummerPipe, "postnummer", false>;
}

declare class CurrencyPipe implements PipeTransform {
    transform(value: number, fractions?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CurrencyPipe, "komponentkartanCurrency", false>;
}

declare class ActionPanelComponent implements OnChanges, OnInit, AfterViewInit {
    private renderer;
    title: string;
    open: boolean;
    showCloseButton: boolean;
    openChanged: EventEmitter<boolean>;
    actionPanelElement: any;
    private readonly slideStateOpen;
    private readonly slideStateClosed;
    private readonly fadeStateVisible;
    private readonly fadeStateHidden;
    slideState: string;
    fadeState: string;
    isOpened: boolean;
    isClosed: boolean;
    elementId: string;
    constructor(renderer: Renderer2);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    close(): void;
    onSlideStart(event: AnimationEvent): void;
    onSlideEnd(event: AnimationEvent): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActionPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActionPanelComponent, "vgr-action-panel", never, { "title": { "alias": "title"; "required": false; }; "open": { "alias": "open"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, { "openChanged": "openChanged"; }, never, ["*"], false, never>;
}

declare class ButtonComponent implements OnChanges {
    disabled: boolean;
    buttonStyle: string;
    type: string;
    loadingState: boolean;
    button: ElementRef;
    reenabled: boolean;
    private wasDisabled;
    private activated;
    constructor();
    ngOnChanges(): void;
    checkDisabled(event: Event): void;
    focus(): void;
    onKeyboardActivation(e: KeyboardEvent): void;
    calculateClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "vgr-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "buttonStyle": { "alias": "buttonStyle"; "required": false; }; "type": { "alias": "type"; "required": false; }; "loadingState": { "alias": "loadingState"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class LockButtonComponent {
    disabled: boolean;
    locked: boolean;
    lockChanged: EventEmitter<boolean>;
    get label(): string;
    toggleLocked(): void;
    checkDisabled(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LockButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LockButtonComponent, "vgr-lock-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "locked": { "alias": "locked"; "required": false; }; }, { "lockChanged": "lockChanged"; }, never, never, false, never>;
}

declare class SaveCancelComponent implements OnInit {
    locked: boolean;
    secondary: boolean;
    hideLock: boolean;
    saveButtonText: string;
    cancel: EventEmitter<any>;
    save: EventEmitter<any>;
    unlock: EventEmitter<any>;
    ngOnInit(): void;
    onLockChanged(locked: boolean): void;
    onSave(): void;
    onCancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SaveCancelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SaveCancelComponent, "vgr-save-cancel", never, { "locked": { "alias": "locked"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "hideLock": { "alias": "hideLock"; "required": false; }; "saveButtonText": { "alias": "saveButtonText"; "required": false; }; }, { "cancel": "cancel"; "save": "save"; "unlock": "unlock"; }, never, never, false, never>;
}

declare class PageHeaderHeightService {
    private heightSource;
    heightChanged: rxjs.Observable<number>;
    height: number;
    setHeight(height: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderHeightService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PageHeaderHeightService>;
}

declare class PageHeaderComponent implements AfterViewChecked {
    private pageHeaderHeightService;
    title: string;
    pageHeader: ElementRef;
    height: number;
    private previousHeight;
    visibleState: boolean;
    constructor(pageHeaderHeightService: PageHeaderHeightService);
    ngAfterViewChecked(): void;
    setHeight(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageHeaderComponent, "vgr-page-header", never, { "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], false, never>;
}

interface SelectableItem<TValue> {
    displayName: string;
    value: TValue;
    selected?: boolean;
    disabled?: boolean;
}
interface ISelectableItem {
    displayName: string;
    id: string;
    selected?: boolean;
    disabled?: boolean;
}

declare class RadioGroupComponent implements ControlValueAccessor, OnChanges, AfterViewInit {
    private controlContainer;
    private elementRef;
    private renderer;
    hasClass: boolean;
    role: string;
    disabled: boolean;
    vertical: boolean;
    formControlName?: string;
    set options(items: SelectableItem<any>[]);
    selectedChanged: EventEmitter<any>;
    radiogroupItems: RadioGroupItem<any>[];
    control: AbstractControl;
    elements: any;
    selectedOption: RadioGroupItem<any>;
    get noSelectionFlag(): boolean;
    constructor(controlContainer: ControlContainer, elementRef: ElementRef, renderer: Renderer2);
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    focus(): void;
    optionClicked(option: RadioGroupItem<any>): void;
    keyDown(event: KeyboardEvent, option: RadioGroupItem<any>): void;
    setFocus(option: RadioGroupItem<any>, direction?: string): void;
    checkTabFocus(index: number): boolean;
    writeValue(option: any): void;
    registerOnChange(func: any): void;
    registerOnTouched(func: any): void;
    onChange(input: SelectableItem<any>): void;
    onTouched(): void;
    onLeave(): void;
    setDisabledState(isDisabled: boolean): void;
    private selectOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, [{ optional: true; host: true; skipSelf: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "vgr-radio-group", never, { "disabled": { "alias": "disabled"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "selectedChanged": "selectedChanged"; }, never, never, false, never>;
}
interface RadioGroupItem<TValue> extends SelectableItem<TValue> {
    ariaid?: string;
}

declare abstract class MenuItemBaseDirective {
    home: EventEmitter<null>;
    end: EventEmitter<null>;
    escape: EventEmitter<null>;
    arrowUp: EventEmitter<null>;
    arrowDown: EventEmitter<null>;
    tab: EventEmitter<null>;
    enter: EventEmitter<null>;
    showExpanded: boolean;
    constructor();
    setFocus(movingUp?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemBaseDirective, never, never, {}, { "home": "home"; "end": "end"; "escape": "escape"; "arrowUp": "arrowUp"; "arrowDown": "arrowDown"; "tab": "tab"; "enter": "enter"; "showExpanded": "showExpanded"; }, never, never, true, never>;
}

declare class HeaderMenuComponent implements AfterContentInit, OnDestroy, OnChanges {
    private elementRef;
    private ngUnsubscribe;
    menuItems: QueryList<MenuItemBaseDirective>;
    userName: string;
    initials: string;
    textColor: string;
    circleColor: string;
    internalInitials: string;
    hideMenu: boolean;
    constructor(elementRef: ElementRef);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    clickToggleHeaderMenu(event: Event): void;
    closeMenuOnClick(event: any, menuItems: any): void;
    keyToggleHeaderMenu(event: KeyboardEvent): void;
    toggleHeaderMenu(event: MouseEvent | any): void;
    focusFirstMenuItem(): void;
    onDocumentClick(event: any): void;
    onDocumentKeyPressed(event: any): void;
    hideMenuAction(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private getInitialsFromUserName;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderMenuComponent, "vgr-header-menu", never, { "userName": { "alias": "userName"; "required": false; }; "initials": { "alias": "initials"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "circleColor": { "alias": "circleColor"; "required": false; }; }, {}, ["menuItems"], ["*"], false, never>;
}

declare class HeaderComponent {
    systemText: string;
    hideSwosh: boolean;
    logoClass: string;
    headerMenuComponent: HeaderMenuComponent;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "vgr-header", never, { "systemText": { "alias": "systemText"; "required": false; }; "hideSwosh": { "alias": "hideSwosh"; "required": false; }; "logoClass": { "alias": "logoClass"; "required": false; }; }, {}, ["headerMenuComponent"], ["*"], false, never>;
}

declare class LoginInformationComponent {
    userName: string;
    initials: string;
    textColor: string;
    circleColor: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginInformationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginInformationComponent, "vgr-login-information", never, { "userName": { "alias": "userName"; "required": false; }; "initials": { "alias": "initials"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "circleColor": { "alias": "circleColor"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CheckboxComponent implements ControlValueAccessor, OnChanges, AfterViewInit {
    private controlContainer;
    private elementRef;
    get disabled(): boolean;
    set disabled(val: boolean);
    checked: boolean;
    label: string;
    formControlName?: string;
    transparent: boolean;
    required: boolean;
    showValidation: boolean;
    checkedChanged: EventEmitter<any>;
    checkbox: ElementRef;
    control: AbstractControl;
    labelledbyid: string;
    element: any;
    groupDisabledOverride: boolean;
    validationErrorMessage: string;
    elementId: string;
    _disabled: boolean;
    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    getLabelFromId(): HTMLLabelElement;
    get errorActive(): any;
    setDisabledState(isDisabled: boolean): void;
    ngAfterViewInit(): void;
    onClick(event: Event): void;
    onKeyDown(event: KeyboardEvent): void;
    onLeave(event: any): void;
    writeValue(value: any): void;
    registerOnChange(func: any): void;
    registerOnTouched(func: any): void;
    onChange(input: any): void;
    onTouched(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "vgr-checkbox", never, { "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "label": { "alias": "label"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; }, { "checkedChanged": "checkedChanged"; }, never, never, false, never>;
}

declare class ModalService {
    private modalOpenedSource;
    private modalClosedSource;
    private modalUpdateSource;
    modalOpened$: Observable<string>;
    modalClosed$: Observable<string>;
    modalUpdate$: Observable<string>;
    openDialog(elementId: string): void;
    closeDialog(elementId: string): void;
    updateDialog(elementId: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}

declare class ModalPlaceholderComponent implements AfterViewChecked, AfterContentInit, OnDestroy {
    private modalService;
    private elementRef;
    private renderer;
    outsideClick: EventEmitter<any>;
    isOpen: boolean;
    elementId: string;
    title: string;
    modalInitialized: boolean;
    lastFocusedElement: any;
    firstTabStop: any;
    lastTabStop: any;
    private ngUnsubscribe;
    focusableElementsString: string;
    focusableNodes: NodeList;
    buttonComponents: QueryList<ElementRef>;
    constructor(modalService: ModalService, elementRef: ElementRef, renderer: Renderer2);
    ngOnDestroy(): void;
    ngAfterViewChecked(): void;
    ngAfterContentInit(): void;
    initFocusableElements(): void;
    private openModal;
    private closeModal;
    onKeyDown(e: KeyboardEvent): void;
    onOutsideClick(e: MouseEvent): void;
    private checkIfOnFocusableNode;
    private handleTabPress;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalPlaceholderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalPlaceholderComponent, "vgr-modal", never, {}, { "outsideClick": "outsideClick"; }, ["buttonComponents"], ["vgr-modal-header", "vgr-modal-content", "vgr-modal-footer"], false, never>;
}

declare class ModalContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalContentComponent, "vgr-modal-content", never, {}, {}, never, ["*"], false, never>;
}

declare class ModalHeaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderComponent, "vgr-modal-header", never, {}, {}, never, ["*"], false, never>;
}

declare class ModalFooterComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalFooterComponent, "vgr-modal-footer", never, {}, {}, never, ["*"], false, never>;
}

declare class CardColumnComponent {
    cardTopClass: boolean;
    cardSectionContainer: boolean;
    left: boolean;
    right: boolean;
    fullwidth: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CardColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardColumnComponent, "vgr-card-column", never, {}, {}, never, ["*"], false, never>;
}

declare class CardComponent implements AfterContentInit {
    columns: QueryList<CardColumnComponent>;
    constructor();
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "vgr-card", never, {}, {}, ["columns"], ["vgr-card-header", "vgr-card-column"], false, never>;
}

declare class CardHeaderComponent {
    cardTopClass: boolean;
    cardHeaderClass: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "vgr-card-header", never, {}, {}, never, ["*"], false, never>;
}

declare class CardSectionComponent {
    cardSectionClass: boolean;
    expanded: boolean;
    readonly: boolean;
    title: string;
    subtitle: string;
    truncateLength: number;
    backgroundColor: string;
    cardSectionHeader: ElementRef;
    overflow: boolean;
    animationSpeed: string;
    expandOverflow: boolean;
    toggleExpanded(event: any): void;
    constructor();
    toggleState(state: 'start' | 'done', expanded: boolean): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardSectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardSectionComponent, "vgr-card-section", never, { "expanded": { "alias": "expanded"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "truncateLength": { "alias": "truncateLength"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class TitleValueComponent {
    titleValueClass: boolean;
    get isSlim(): boolean;
    slim: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleValueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleValueComponent, "vgr-title-value", never, { "slim": { "alias": "slim"; "required": false; }; }, {}, never, ["vgr-title-value-heading", "vgr-title-value-container"], false, never>;
}

declare class TitleValueLayoutComponent {
    TitleValueLayoutClass: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleValueLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleValueLayoutComponent, "vgr-title-value-layout", never, {}, {}, never, ["*"], false, never>;
}

declare class TitleValueHeadingComponent {
    for: string;
    width: number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleValueHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleValueHeadingComponent, "vgr-title-value-heading", never, { "for": { "alias": "for"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class TitleValueContainerComponent {
    width: number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleValueContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleValueContainerComponent, "vgr-title-value-container", never, { "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class LoaderComponent {
    private changeDetector;
    private _minimumTimeMs;
    private lastActivated;
    private _active;
    visible: boolean;
    set active(value: boolean);
    get active(): boolean;
    small: boolean;
    constructor(changeDetector: ChangeDetectorRef);
    private startSpinning;
    private stopSpinning;
    private hideWhenMinimumTimeHasPassed;
    private showForMinimumTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "vgr-loader", never, { "active": { "alias": "active"; "required": false; }; "small": { "alias": "small"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SkeletonLoaderComponent {
    private changeDetector;
    private _minimumTimeMs;
    private lastActivated;
    private _active;
    visible: boolean;
    set active(value: boolean);
    get active(): boolean;
    width: string;
    height: string;
    circle: boolean;
    constructor(changeDetector: ChangeDetectorRef);
    private startSpinning;
    private stopSpinning;
    private hideWhenMinimumTimeHasPassed;
    private showForMinimumTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonLoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonLoaderComponent, "vgr-skeleton-loader", never, { "active": { "alias": "active"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "circle": { "alias": "circle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PageComponent implements OnInit, OnDestroy {
    private pageHeaderHeightService;
    bodyContainer: ElementRef;
    private ngUnsubscribe;
    constructor(pageHeaderHeightService: PageHeaderHeightService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageComponent, "vgr-page", never, {}, {}, never, ["vgr-page-header", "vgr-page-body"], false, never>;
}

declare class PageBodyComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<PageBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageBodyComponent, "vgr-page-body", never, {}, {}, never, ["*"], false, never>;
}

declare class PageBlockComponent {
    transparent: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PageBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PageBlockComponent, "vgr-page-block", never, { "transparent": { "alias": "transparent"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class TextareaComponent implements AfterViewInit, OnChanges, ControlValueAccessor, OnDestroy {
    private controlContainer;
    private cdRef;
    private el;
    showValidation: boolean;
    width: string;
    height: string;
    placeholder: string;
    formControlName: string;
    maxlength: number;
    value: string;
    labelId: string;
    disabled: boolean;
    readonly?: boolean;
    get errorClass(): boolean;
    get editingClass(): boolean;
    textareaElement: ElementRef;
    scrollHeight: string;
    control: AbstractControl;
    hasFocus: boolean;
    cancel: boolean;
    elementId: string;
    validationErrorMessage: string;
    private ngUnsubscribe;
    constructor(controlContainer: ControlContainer, cdRef: ChangeDetectorRef, el: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    focus(): void;
    writeValue(value: any): void;
    registerOnChange(func: any): void;
    registerOnTouched(func: any): void;
    setDisabledState(isDisabled: boolean): void;
    onChange(input: any): void;
    onTouched(input: any): void;
    onBlur(event: Event): void;
    onFocus(event: Event): void;
    ngOnDestroy(): void;
    get errorActive(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, [{ optional: true; host: true; skipSelf: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "vgr-textarea", never, { "showValidation": { "alias": "showValidation"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "value": { "alias": "value"; "required": false; }; "labelId": { "alias": "labelId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RadiobuttonItemComponent implements AfterViewInit {
    private elementRef;
    groupDisabledOverride: boolean;
    elementId: string;
    set selected(val: boolean);
    value: string | number;
    label: string;
    set disabled(val: boolean);
    get disabled(): boolean;
    get selected(): boolean;
    itemSelected: EventEmitter<any>;
    itemDisabled: EventEmitter<any>;
    item: ElementRef;
    radioButton: ElementRef;
    radioButtonContent: ElementRef;
    tabIndex: number;
    _disabled: boolean;
    _selected: boolean;
    set tabEnabled(val: boolean);
    isTabEnabled: boolean;
    constructor(elementRef: ElementRef);
    ngAfterViewInit(): void;
    itemClicked(): void;
    firstfocusIn(): void;
    focus(): void;
    hasFocus(): boolean;
    checkTabFocus(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadiobuttonItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadiobuttonItemComponent, "vgr-radiobutton-item", never, { "selected": { "alias": "selected"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "itemSelected": "itemSelected"; "itemDisabled": "itemDisabled"; }, ["radioButtonContent"], ["*"], false, never>;
}

declare class RadiobuttonGroupComponent implements ControlValueAccessor, AfterContentInit, OnChanges, OnDestroy {
    private controlContainer;
    private elementRef;
    _disabled: boolean;
    _value: string | number;
    showValidation: boolean;
    set value(val: string | number);
    get value(): string | number;
    set disabled(val: any);
    vertical: boolean;
    formControlName?: string;
    required: boolean;
    selectedChanged: EventEmitter<RadiobuttonItemComponent>;
    items: QueryList<RadiobuttonItemComponent>;
    ngUnsubscribeItems: any;
    internalDisabled: boolean;
    validationErrorMessage: string;
    elementId: string;
    control: AbstractControl;
    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
    ngAfterContentInit(): void;
    setFirstOptionAsFocusable(): void;
    ngOnChanges(): void;
    get errorActive(): any;
    ngOnDestroy(): void;
    unSelectItems(itemToExclude?: RadiobuttonItemComponent): void;
    disabledItems(): void;
    setGroupDisabledOverride(groupDisabledState: boolean): void;
    setPreselectedValue(): void;
    keyDown(event: KeyboardEvent): void;
    setSelectedValue(value: string | number): void;
    setFocus(option: any, direction?: string): void;
    onTouched(): void;
    onChange(input: RadiobuttonItemComponent): void;
    onLeave(): void;
    writeValue(value: string | number): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    getLabelFromId(): HTMLLabelElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadiobuttonGroupComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadiobuttonGroupComponent, "vgr-radiobutton-group", never, { "showValidation": { "alias": "showValidation"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "selectedChanged": "selectedChanged"; }, ["items"], ["vgr-radiobutton-item"], false, never>;
}

declare class InputComponent implements ControlValueAccessor, OnChanges, OnInit, AfterViewInit {
    private controlContainer;
    private el;
    renderer: Renderer2;
    private cdr;
    showValidation: boolean;
    readonly: boolean;
    disabledControl: boolean;
    hasSuffix: boolean;
    width: string;
    /** DEFAULT INPUT OPTIONS FORWARDED **/
    required: boolean;
    step: any;
    pattern: any;
    labelId: string;
    maxlength: number;
    minlength: number;
    min: number;
    max: number;
    placeholder: string;
    name: string;
    type: 'text' | 'email' | 'number' | 'password' | 'search' | 'tel';
    value: any;
    aria: any;
    /**  */
    formControlName: string;
    prefix: string;
    suffix: string;
    textAlign: string;
    errorMessage: any;
    blur: EventEmitter<any>;
    inputElement: ElementRef;
    control: AbstractControl;
    hasFocus: boolean;
    elementId: string;
    mouseDown: boolean;
    constructor(controlContainer: ControlContainer, el: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    setDisabledState(isDisabled: boolean): void;
    get errorActive(): any;
    propagateChange: (_: any) => void;
    propagateTouch: (_: any) => void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onChange(event: KeyboardEvent): void;
    onBlur(event: any): void;
    onClickFocus(event: any): void;
    onFocus(event: any): void;
    focus(): void;
    getLabelFromId(): HTMLLabelElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, [{ optional: true; host: true; skipSelf: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "vgr-input", never, { "showValidation": { "alias": "showValidation"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabledControl": { "alias": "disabledControl"; "required": false; }; "width": { "alias": "width"; "required": false; }; "required": { "alias": "required"; "required": false; }; "step": { "alias": "step"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "labelId": { "alias": "labelId"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "aria": { "alias": "aria"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, { "blur": "blur"; }, never, never, false, never>;
}

declare class MenuComponent implements AfterContentInit, OnDestroy {
    private ngUnsubscribe;
    title: string;
    hasClass: boolean;
    menuItems: QueryList<MenuItemBaseDirective>;
    role: string;
    orientation: string;
    get smallerFont(): boolean;
    constructor();
    ngAfterContentInit(): void;
    addSubscriptions(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "vgr-menu", never, { "title": { "alias": "title"; "required": false; }; }, {}, ["menuItems"], ["*"], false, never>;
}

declare class MenuItemComponent extends MenuItemBaseDirective implements AfterViewInit {
    private router;
    private renderer;
    text: string;
    link: string;
    action: EventEmitter<KeyboardEvent | MouseEvent>;
    disabled: boolean;
    disabledTooltip: string;
    notification: string;
    notificationColor: string;
    notificationTooltip: string;
    isInternalLink: boolean;
    role: string;
    ariaDisabled: any;
    menuitem: ElementRef;
    elementId: string;
    onKeyDown(event: KeyboardEvent): void;
    get notificationColorClass(): string;
    get notificationText(): string;
    constructor(router: Router, renderer: Renderer2);
    setFocus(movingUp?: boolean): void;
    ngAfterViewInit(): void;
    onExternalLink(): Window;
    onAction(event: MouseEvent | KeyboardEvent): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "vgr-menu-item", never, { "text": { "alias": "text"; "required": false; }; "link": { "alias": "link"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disabledTooltip": { "alias": "disabledTooltip"; "required": false; }; "notification": { "alias": "notification"; "required": false; }; "notificationColor": { "alias": "notificationColor"; "required": false; }; "notificationTooltip": { "alias": "notificationTooltip"; "required": false; }; "isInternalLink": { "alias": "isInternalLink"; "required": false; }; }, { "action": "action"; }, never, never, false, never>;
}

declare class MenuSeparatorComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuSeparatorComponent, "vgr-menu-separator", never, {}, {}, never, never, false, never>;
}

declare class PanelComponent {
    private elementRef;
    width: number;
    themecolor: string;
    noborder: boolean;
    get classes(): string;
    private getColumnWidthClass;
    private getColorClass;
    private getBorderClass;
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PanelComponent, "vgr-panel", never, { "width": { "alias": "width"; "required": false; }; "themecolor": { "alias": "themecolor"; "required": false; }; "noborder": { "alias": "noborder"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class PanelContainerComponent {
    private elementRef;
    panelContainerClass: boolean;
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PanelContainerComponent, "vgr-panel-container", never, {}, {}, never, ["vgr-panel"], false, never>;
}

declare class ExpandableDivComponent {
    expanded: boolean;
    expandedChanged: EventEmitter<boolean>;
    header: ElementRef;
    onKeydown(event: KeyboardEvent): void;
    toggleExpanded(): void;
    collapse(): void;
    expand(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableDivComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableDivComponent, "vgr-expandable-div", never, { "expanded": { "alias": "expanded"; "required": false; }; }, { "expandedChanged": "expandedChanged"; }, never, ["vgr-expandable-div-header", "vgr-expandable-div-content"], false, never>;
}

declare class ExpandableDivHeaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableDivHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableDivHeaderComponent, "vgr-expandable-div-header", never, {}, {}, never, ["*"], false, never>;
}

declare class ExpandableDivContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableDivContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableDivContentComponent, "vgr-expandable-div-content", never, {}, {}, never, ["*"], false, never>;
}

declare class CloseButtonComponent {
    disabled: boolean;
    checkDisabled(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CloseButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CloseButtonComponent, "vgr-close-button", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RingWithTextComponent implements OnChanges {
    size: string;
    text: string;
    textColor: string;
    circleColor: string;
    ringSize: string;
    constructor();
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RingWithTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RingWithTextComponent, "vgr-ring-with-text", never, { "size": { "alias": "size"; "required": false; }; "text": { "alias": "text"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "circleColor": { "alias": "circleColor"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TableComponent {
    tableClass: string;
    expanded: boolean;
    expandable: boolean;
    percentLayout: boolean;
    expandedChanged: EventEmitter<boolean>;
    table: ElementRef;
    animationSpeed: string;
    toggleRow(event: KeyboardEvent): void;
    toggleExpansion(expandable?: boolean): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "vgr-table", never, { "expanded": { "alias": "expanded"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; "percentLayout": { "alias": "percentLayout"; "required": false; }; }, { "expandedChanged": "expandedChanged"; }, never, ["vgr-table-header", "vgr-table-row", "vgr-table"], false, never>;
}

declare class TableRowColumnComponent {
    private table;
    width: number;
    align: string;
    get classes(): string;
    constructor(table: TableComponent);
    getColumnWidthClass(): string;
    getAlignClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowColumnComponent, [{ optional: true; host: true; skipSelf: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowColumnComponent, "vgr-table-row-column", never, { "width": { "alias": "width"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class TableHeaderColumnComponent {
    private table;
    width: number;
    align: string;
    get classes(): string;
    constructor(table: TableComponent);
    getColumnWidthClass(): string;
    getAlignClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderColumnComponent, [{ optional: true; host: true; skipSelf: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderColumnComponent, "vgr-table-header-column", never, { "width": { "alias": "width"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class TableRowComponent {
    tableRowClass: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRowComponent, "vgr-table-row", never, {}, {}, never, ["vgr-table-row-column"], false, never>;
}

declare class TableHeaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeaderComponent, "vgr-table-header", never, {}, {}, never, ["*"], false, never>;
}

declare class FilterTagComponent implements AfterViewInit {
    disabled: boolean;
    ariaLabel: string;
    next: EventEmitter<any>;
    previous: EventEmitter<any>;
    remove: EventEmitter<any>;
    filtertag: ElementRef;
    content: ElementRef;
    tabindex: number;
    removed: boolean;
    removing: boolean;
    ngAfterViewInit(): void;
    makeTabFocusable(focusable: boolean): void;
    onKeydown(event: KeyboardEvent): void;
    focus(): void;
    emitRemove(): void;
    checkDisabled(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTagComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterTagComponent, "vgr-filter-tag", never, { "disabled": { "alias": "disabled"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "next": "next"; "previous": "previous"; "remove": "remove"; }, never, ["*"], false, never>;
}

declare class FilterTagGroupComponent implements AfterContentInit, OnDestroy {
    filterTags: QueryList<FilterTagComponent>;
    filterTagSubscriptions: any[];
    lastSelectedIndex: number;
    private ngUnsubscribe;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    setFilterTagTabFocusability(): void;
    setFilterTagFocus(): void;
    addFilterTagSubscriptions(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTagGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterTagGroupComponent, "vgr-filter-tag-group", never, {}, {}, ["filterTags"], ["*"], false, never>;
}

declare class ScrollToTopComponent {
    visibleState: boolean;
    onWindowScroll(): void;
    constructor();
    scrollToTop(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToTopComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollToTopComponent, "vgr-scroll-to-top", never, {}, {}, never, never, false, never>;
}

declare class SearchResultComponent implements OnChanges, OnInit {
    private elementRef;
    description: string;
    noResultsText: string;
    items: any;
    maxItems: number;
    width: string;
    displayItems: any;
    focusItem: number;
    visible: boolean;
    visibleChange: EventEmitter<any>;
    itemClick: EventEmitter<any>;
    descriptionHeight: number;
    onDocumentClick(event: any): void;
    constructor(elementRef: ElementRef);
    ngOnInit(): void;
    ngOnChanges(): void;
    resetScrollPosition(): void;
    handleKeyevents(event: any): void;
    indexInParent(node: any): number;
    setFocusedElement(): void;
    getParentNode(): any;
    filterItems(): void;
    onItemClick(item: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchResultComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchResultComponent, "vgr-search-result", never, { "description": { "alias": "description"; "required": false; }; "noResultsText": { "alias": "noResultsText"; "required": false; }; "items": { "alias": "items"; "required": false; }; "maxItems": { "alias": "maxItems"; "required": false; }; "width": { "alias": "width"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, { "visibleChange": "visibleChange"; "itemClick": "itemClick"; }, never, never, false, never>;
}

declare class ToggleButtonComponent implements AfterViewInit, OnChanges {
    disabled: boolean;
    pressed: boolean;
    ariaLabel: string;
    next: EventEmitter<any>;
    previous: EventEmitter<any>;
    togglebutton: ElementRef;
    content: ElementRef;
    tabindex: number;
    ariaPressed: boolean;
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    makeTabFocusable(focusable: boolean): void;
    onKeydown(event: KeyboardEvent): void;
    checkDisabled(event: MouseEvent): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonComponent, "vgr-toggle-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "pressed": { "alias": "pressed"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "next": "next"; "previous": "previous"; }, never, ["*"], false, never>;
}

declare class ToggleButtonGroupComponent implements AfterContentInit, OnDestroy {
    width: string;
    toggleButtons: QueryList<ToggleButtonComponent>;
    toggleButtonSubscriptions: any[];
    lastSelectedIndex: number;
    private ngUnsubscribe;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    setToggleButtonTabFocusability(): void;
    setToggleButtonFocus(): void;
    addToggleButtonSubscriptions(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonGroupComponent, "vgr-toggle-button-group", never, { "width": { "alias": "width"; "required": false; }; }, {}, ["toggleButtons"], ["*"], false, never>;
}

declare class TabButtonComponent implements AfterViewInit, OnChanges {
    disabled: boolean;
    active: boolean;
    ariaLabel: string;
    tabId: string;
    width: string;
    parentId: any;
    next: EventEmitter<any>;
    previous: EventEmitter<any>;
    home: EventEmitter<any>;
    end: EventEmitter<any>;
    selectedChanged: EventEmitter<string>;
    tabbutton: ElementRef;
    content: ElementRef;
    tabindex: number;
    ariaPressed: boolean;
    initialTabId: string;
    constructor();
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    makeTabFocusable(focusable: boolean): void;
    onKeydown(event: KeyboardEvent): void;
    focus(): void;
    onChange(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabButtonComponent, "vgr-tab-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "active": { "alias": "active"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "tabId": { "alias": "tabId"; "required": false; }; "width": { "alias": "width"; "required": false; }; "parentId": { "alias": "parentId"; "required": false; }; }, { "next": "next"; "previous": "previous"; "home": "home"; "end": "end"; "selectedChanged": "selectedChanged"; }, never, ["*"], false, never>;
}

declare class TabManagementService {
    navigateAborted: boolean;
    subject: Subject<any>;
    private messageSource;
    private currentTab;
    changeNavigation: rxjs.Observable<boolean>;
    tabChanged: rxjs.Observable<any>;
    navigationCancelled(navigated: boolean): void;
    tabChangeRequested(tab: any, id: any): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TabManagementService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TabManagementService>;
}

declare class TabButtonGroupComponent implements AfterContentInit, OnDestroy {
    private tabManagementService;
    width: string;
    id: string;
    alignCenter: boolean;
    tabButtons: QueryList<TabButtonComponent>;
    tabButtonSubscriptions: any[];
    lastSelectedIndex: number;
    activeTabId: string;
    previousActiveTabId: string;
    private ngUnsubscribe;
    _navigationCancelled: boolean;
    get navigationCancelled(): boolean;
    constructor(tabManagementService: TabManagementService);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    setTabButtonTabFocusability(): void;
    setTabButtonFocus(): void;
    addTabButtonSubscriptions(): void;
    setActiveTabId(tabId: string): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabButtonGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabButtonGroupComponent, "vgr-tab-button-group", never, { "width": { "alias": "width"; "required": false; }; "id": { "alias": "id"; "required": false; }; "alignCenter": { "alias": "alignCenter"; "required": false; }; }, {}, ["tabButtons"], ["*"], false, never>;
}

interface PageItem {
    label: string;
    ariaLabel: string;
    active: boolean;
    tabindex: number;
    buttonIndex: number;
    action: () => void;
}

declare class PaginationManagementService {
    navigateAborted: boolean;
    subject: Subject<any>;
    private messageSource;
    changeNavigation: rxjs.Observable<boolean>;
    navigationCancelled(navigated: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationManagementService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationManagementService>;
}

declare class PaginationComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    private paginationManagementService;
    pages: number;
    activePage: number;
    pageChanged: EventEmitter<number>;
    pageButtons: QueryList<ElementRef>;
    pageItems: PageItem[];
    focusedPageLabel: string;
    nextPage: EventEmitter<any>;
    previousPage: EventEmitter<any>;
    private _activePage;
    private ngUnsubscribe;
    previousActivePage: number;
    _navigationCancelled: boolean;
    get navigationCancelled(): boolean;
    constructor(paginationManagementService: PaginationManagementService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onPageButtonFocus(event: FocusEvent): void;
    onPageButtonBlur(event: FocusEvent): void;
    onKeydown(event: KeyboardEvent, index: number): void;
    private focusPreviousPageItem;
    private focusNextPageItem;
    private focusPreviousButton;
    private focusNextButton;
    private showPage;
    private setPageItems;
    private addFirstPageItem;
    private addLastPageItem;
    private addPageItem;
    private setAriaLabel;
    private addDots;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "vgr-pagination", never, { "pages": { "alias": "pages"; "required": false; }; "activePage": { "alias": "activePage"; "required": false; }; }, { "pageChanged": "pageChanged"; }, never, never, false, never>;
}

declare class DropdownItemComponent implements AfterViewInit {
    selectedLabel: string;
    value: any;
    toggle: EventEmitter<any>;
    confirm: EventEmitter<any>;
    previous: EventEmitter<any>;
    next: EventEmitter<any>;
    nextMatch: EventEmitter<string>;
    item: ElementRef;
    label: string;
    multi: boolean;
    selected: boolean;
    visible: boolean;
    hasFocus: boolean;
    ngAfterViewInit(): void;
    toggleSelect(): void;
    focus(): void;
    onFocus(): void;
    onBlur(): void;
    onKeydown(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownItemComponent, "vgr-dropdown-item", never, { "selectedLabel": { "alias": "selectedLabel"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "toggle": "toggle"; "confirm": "confirm"; "previous": "previous"; "next": "next"; "nextMatch": "nextMatch"; }, never, ["*"], false, never>;
}

declare function _defaultCompare$1(o1: any, o2: any): boolean;
declare class DropdownSelectComponent implements OnChanges, AfterContentInit, AfterViewInit, OnDestroy, ControlValueAccessor {
    formControl: NgControl;
    private elementRef;
    multi: boolean;
    deselectable: boolean;
    simpleLabel: boolean;
    noItemSelectedLabel: string;
    readonly: boolean;
    disabled: boolean;
    showValidation: boolean;
    errorMessage: {};
    compareWith: typeof _defaultCompare$1;
    labelId: string;
    value: any;
    width: string;
    small: boolean;
    rightAlign: boolean;
    topAlign: boolean;
    selectedChanged: EventEmitter<any>;
    expandedChanged: EventEmitter<boolean>;
    dropdown: ElementRef;
    scrollbarRef: NgScrollbar;
    header: ElementRef;
    selectAll: ElementRef;
    deselectButton: ButtonComponent;
    filter: InputComponent;
    items: QueryList<DropdownItemComponent>;
    scrollSubscription: Subscription;
    expanded: boolean;
    filterVisible: boolean;
    allSelected: boolean;
    deselectDisabled: boolean;
    headerLabelId: string;
    label: string;
    hasFocus: boolean;
    filterHasFocus: boolean;
    visibleCount: number;
    searchString: string;
    elementId: string;
    truncateTextLength: number;
    private matchQuery;
    get combinedLabelIds(): string;
    get errorActive(): boolean;
    get errorEditing(): boolean;
    private ngUnsubscribe;
    private ngUnsubscribeItems;
    onDocumentClick(event: any): void;
    constructor(formControl: NgControl, elementRef: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    focus(): void;
    writeValue(value: any): void;
    registerOnChange(func: (value: any) => any): void;
    registerOnTouched(func: () => any): void;
    onChange(value: any): void;
    onTouched(): void;
    toggleExpanded(): void;
    filterItems(): void;
    deselectItems(): void;
    toggleSelectAll(): void;
    updateAllCheckedStatus(): void;
    onFocus(): void;
    onBlur(event: FocusEvent): void;
    onKeydown(event: KeyboardEvent): void;
    onHeaderKeydown(event: KeyboardEvent): void;
    onFilterFocus(): void;
    onFilterBlur(): void;
    onFilterKeydown(event: KeyboardEvent): void;
    onDeselectKeydown(event: KeyboardEvent): void;
    onSelectAllKeydown(event: KeyboardEvent): void;
    private expand;
    private collapse;
    private setFilterVisibility;
    private setMultiOnItems;
    private subscribeToItems;
    private focusPreviousItem;
    private focusNextItem;
    private focusNextMatchingItem;
    private setLabel;
    private setSelectedState;
    setDisabledState(isDisabled: boolean): void;
    getLabelFromId(): HTMLLabelElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownSelectComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownSelectComponent, "vgr-dropdown-select", never, { "multi": { "alias": "multi"; "required": false; }; "deselectable": { "alias": "deselectable"; "required": false; }; "simpleLabel": { "alias": "simpleLabel"; "required": false; }; "noItemSelectedLabel": { "alias": "noItemSelectedLabel"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "labelId": { "alias": "labelId"; "required": false; }; "value": { "alias": "value"; "required": false; }; "width": { "alias": "width"; "required": false; }; "small": { "alias": "small"; "required": false; }; "rightAlign": { "alias": "rightAlign"; "required": false; }; "topAlign": { "alias": "topAlign"; "required": false; }; }, { "selectedChanged": "selectedChanged"; "expandedChanged": "expandedChanged"; }, ["items"], ["*"], false, never>;
}

declare class IconComponent {
    color: string;
    size: string;
    ariaLabel: string;
    icon: string;
    flip: string;
    pull: string;
    rotate: number;
    solid: boolean;
    fixedWidth: boolean;
    spin: boolean;
    pulse: boolean;
    border: boolean;
    disabled: boolean;
    get prefix(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "vgr-icon", never, { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "flip": { "alias": "flip"; "required": false; }; "pull": { "alias": "pull"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "solid": { "alias": "solid"; "required": false; }; "fixedWidth": { "alias": "fixedWidth"; "required": false; }; "spin": { "alias": "spin"; "required": false; }; "pulse": { "alias": "pulse"; "required": false; }; "border": { "alias": "border"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatepickerItemComponent implements OnInit {
    date: Date;
    type: string;
    selected: boolean;
    disabled: boolean;
    isMinZoom: boolean;
    select: EventEmitter<Date>;
    zoomIn: EventEmitter<Date>;
    previousColumn: EventEmitter<Date>;
    nextColumn: EventEmitter<Date>;
    previousRow: EventEmitter<Date>;
    nextRow: EventEmitter<Date>;
    item: ElementRef;
    dateFormat: string;
    ariaDateFormat: string;
    current: boolean;
    focused: boolean;
    ngOnInit(): void;
    onClick(): void;
    onKeydown(event: KeyboardEvent): void;
    onFocus(): void;
    onBlur(): void;
    focus(): void;
    private activate;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerItemComponent, "vgr-datepicker-item", never, { "date": { "alias": "date"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isMinZoom": { "alias": "isMinZoom"; "required": false; }; }, { "select": "select"; "zoomIn": "zoomIn"; "previousColumn": "previousColumn"; "nextColumn": "nextColumn"; "previousRow": "previousRow"; "nextRow": "nextRow"; }, never, never, false, never>;
}

interface Calendar {
    date: Date;
    items: CalendarItem[][];
    previous: () => void;
    next: () => void;
    farPrevious: () => void;
    farNext: () => void;
    zoomOut: () => void;
}
interface CalendarItem {
    date: Date;
    selected: boolean;
    disabled: boolean;
    isMinZoom: boolean;
}

declare class DatepickerComponent implements OnChanges, AfterViewInit, OnDestroy, ControlValueAccessor {
    private locale;
    formControl: NgControl;
    width: any;
    selectedDate: Date;
    minZoom: string;
    minDate: Date;
    maxDate: Date;
    allowText: boolean;
    disabled: boolean;
    readonly: boolean;
    showValidation: boolean;
    errorMessage: {};
    labelId: string;
    transparent: boolean;
    displayFormat: string;
    selectedDateChanged: EventEmitter<Date>;
    datepicker: ElementRef;
    headerLabel: ElementRef;
    headerInput: ElementRef;
    readOnlyHeader: ElementRef;
    headerInputDiv: ElementRef;
    calendar: ElementRef;
    items: QueryList<DatepickerItemComponent>;
    headerLabelId: string;
    label: string;
    noSelectedDateLabel: string;
    labelDateFormat: string;
    inputPlaceholder: string;
    parseError: boolean;
    parseErrorMessage: string;
    headerHasFocus: boolean;
    expanded: boolean;
    years: Calendar;
    months: Calendar;
    days: Calendar;
    zoomedToYears: boolean;
    zoomedToMonths: boolean;
    zoomedToDays: boolean;
    private minZoomLevel;
    private actualMinDate;
    private actualMaxDate;
    private ngUnsubscribe;
    private ngUnsubscribeItems;
    elementId: string;
    mouseDown: any;
    onWindowResize(): void;
    get errorActive(): boolean;
    get errorEditing(): boolean;
    constructor(locale: string, formControl: NgControl);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    focus(): void;
    setFocusOnHeaderInput(): void;
    writeValue(value: Date): void;
    registerOnChange(func: (value: any) => any): void;
    registerOnTouched(func: (value: any) => any): void;
    setDisabledState(isDisabled: boolean): void;
    onChange(value: any): void;
    onTouched(value: any): void;
    toggleExpanded(): void;
    onMouseDownClick(): void;
    onHeaderFocus(): void;
    onHeaderBlur(): void;
    onBlur(event: FocusEvent): void;
    onHeaderInputKeydown(event: KeyboardEvent): void;
    onKeydown(event: KeyboardEvent): void;
    onHeaderClick(): void;
    onHeaderKeydown(event: KeyboardEvent): void;
    onCalendarKeydown(event: KeyboardEvent): void;
    parseSelectedDate(value: string): void;
    private expand;
    private collapse;
    private zoomToDays;
    private zoomToMonths;
    private zoomToYears;
    private setMinZoomLevel;
    private setSelectedDate;
    private formatDate;
    private subscribeToItems;
    getLabelFromId(): HTMLLabelElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerComponent, [null, { optional: true; self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerComponent, "vgr-datepicker", never, { "width": { "alias": "width"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "minZoom": { "alias": "minZoom"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "allowText": { "alias": "allowText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "labelId": { "alias": "labelId"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; }, { "selectedDateChanged": "selectedDateChanged"; }, never, never, false, never>;
}

declare class ScrollbarComponent {
    scrollable: NgScrollbar;
    autoheightDisabled: string;
    autowidthDisabled: string;
    visibility: string;
    maxHeight: any;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollbarComponent, "vgr-scrollbar", never, { "autoheightDisabled": { "alias": "autoheightDisabled"; "required": false; }; "autowidthDisabled": { "alias": "autowidthDisabled"; "required": false; }; "visibility": { "alias": "visibility"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class ComboboxItemComponent implements AfterViewInit {
    selectedLabel: string;
    value: any;
    select: EventEmitter<any>;
    item: ElementRef;
    label: string;
    index: number;
    selected: boolean;
    highlighted: boolean;
    visible: boolean;
    hasFocus: boolean;
    ngAfterViewInit(): void;
    setSelected(): void;
    setIndex(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxItemComponent, "vgr-combobox-item", never, { "selectedLabel": { "alias": "selectedLabel"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "select": "select"; }, never, ["*"], false, never>;
}

declare function _defaultCompare(o1: any, o2: any): boolean;
declare class ComboboxComponent implements OnChanges, AfterContentInit, AfterViewInit, OnDestroy, ControlValueAccessor {
    formControl: NgControl;
    private elementRef;
    readonly: boolean;
    disabled: boolean;
    showValidation: boolean;
    errorMessage: {};
    value: any;
    labelId: string;
    width: string;
    small: boolean;
    showButton: boolean;
    placeholder: string;
    listAlignRight: boolean;
    compareWith: typeof _defaultCompare;
    selectedChanged: EventEmitter<any>;
    expandedChanged: EventEmitter<boolean>;
    combobox: ElementRef;
    textInput: ElementRef;
    readonlyLabel: ElementRef;
    header: ElementRef;
    scrollable: ScrollbarComponent;
    items: QueryList<ComboboxItemComponent>;
    expanded: boolean;
    headerLabelId: string;
    label: string;
    hasFocus: boolean;
    searchString: string;
    leftPosition: string;
    elementId: string;
    mouseDown: boolean;
    get combinedLabelIds(): string;
    get highlightedItemIndex(): number;
    get errorActive(): boolean;
    get errorEditing(): boolean;
    private ngUnsubscribe;
    private ngUnsubscribeItems;
    onDocumentClick(event: any): void;
    constructor(formControl: NgControl, elementRef: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    focus(): void;
    writeValue(value: any): void;
    registerOnChange(func: (value: any) => any): void;
    registerOnTouched(func: () => any): void;
    onChange(value: any): void;
    onTouched(): void;
    expandListbox(): void;
    filterItems(): void;
    deselectItems(): void;
    onMouseDownClick(): void;
    onFocus(): void;
    onBlur(event: FocusEvent): void;
    onKeydown(event: KeyboardEvent): void;
    setDisabledState(isDisabled: boolean): void;
    private expand;
    private collapse;
    private subscribeToItems;
    private focusPreviousItem;
    private focusNextItem;
    private scrollToItem;
    private setSelectedState;
    private setHighligthState;
    private setHighlightedItem;
    private setInputText;
    getLabelFromId(): HTMLLabelElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxComponent, "vgr-combobox", never, { "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "value": { "alias": "value"; "required": false; }; "labelId": { "alias": "labelId"; "required": false; }; "width": { "alias": "width"; "required": false; }; "small": { "alias": "small"; "required": false; }; "showButton": { "alias": "showButton"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "listAlignRight": { "alias": "listAlignRight"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, { "selectedChanged": "selectedChanged"; "expandedChanged": "expandedChanged"; }, ["items"], ["*"], false, never>;
}

declare enum NotificationType {
    Permanent = 0,
    ShowOnCollapse = 1,
    ShowOnRemove = 2
}

interface NotificationIconTypes {
    /**
     * 'exclamation-cirlce' kräver användning av solid: true
     * 'pen' kräver användning av solid: true
    */
    name: 'pen' | 'comment-dots' | 'trash-alt' | 'check-circle' | 'question-circle' | 'exclamation-circle';
    size?: string;
    color?: 'success' | 'error' | 'disabled' | 'text' | 'light';
    solid?: boolean;
    disabled?: boolean;
}

interface RowNotification {
    icon: NotificationIconTypes;
    type: NotificationType;
    message: string;
    done: boolean;
    removeWhenDone: boolean;
}

declare class ExpandableRow<TPreview, TFull> {
    previewObject: TPreview;
    fullObject: TFull;
    notification: RowNotification;
    constructor(previewObject: TPreview);
    setNotification(message: string, icon: NotificationIconTypes, temporary?: boolean): void;
    notifyOnCollapse(message: string, icon: NotificationIconTypes, clearNotification?: boolean): void;
    notifyOnRemove(message: string, icon: NotificationIconTypes): void;
    removeNotification(): void;
}

interface Notification {
    icon: NotificationIconTypes;
    message: string;
}

interface SearchResultItem {
    displayName: Array<string>;
    value: any;
    secondRowItalic?: boolean;
}

declare class BrowserDetector {
    constructor();
    isInternetExplorer(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserDetector, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserDetector>;
}

declare enum GridSortDirection {
    None = 0,
    Ascending = 1,
    Descending = 2
}
interface SortChangedArgs {
    key: string;
    direction: GridSortDirection;
}
declare class SortArrowComponent implements OnChanges {
    sortDirection: GridSortDirection;
    className: any;
    constructor();
    ngOnChanges(changes: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortArrowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SortArrowComponent, "vgr-sort-arrow", never, { "sortDirection": { "alias": "sortDirection"; "required": false; }; }, {}, never, never, false, never>;
}

declare class GridHeaderColumnComponent {
    private injector;
    width: number;
    align: string;
    sortKey: string;
    sortDirection: GridSortDirection;
    sortChanged: EventEmitter<GridSortDirection>;
    gridHeaderColumn: ElementRef;
    constructor(injector: Injector);
    keydown(event: any): void;
    changeSort(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridHeaderColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridHeaderColumnComponent, "vgr-grid-header-column", never, { "width": { "alias": "width"; "required": false; }; "align": { "alias": "align"; "required": false; }; "sortKey": { "alias": "sortKey"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; }, { "sortChanged": "sortChanged"; }, never, ["*"], false, never>;
}

interface GridSortChangedArgs {
    key: string;
    direction: GridSortDirection;
}
declare class GridHeaderComponent implements AfterContentInit, OnDestroy {
    el: ElementRef;
    gridHeaderColumns: QueryList<GridHeaderColumnComponent>;
    sortChanged: EventEmitter<GridSortChangedArgs>;
    focusChanged: EventEmitter<number>;
    private ngUnsubscribe;
    previousSortableColumn(startIndex: number): number;
    nextSortableColumn(startIndex: number): number;
    constructor(el: ElementRef);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    onColumnSortChanged(column: GridHeaderColumnComponent, direction: GridSortDirection): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridHeaderComponent, "vgr-grid-header", never, {}, { "sortChanged": "sortChanged"; "focusChanged": "focusChanged"; }, ["gridHeaderColumns"], ["vgr-grid-header-column"], false, never>;
}

declare class GridContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GridContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridContentComponent, "vgr-grid-content", never, {}, {}, never, ["*"], false, never>;
}

declare class GridService {
    private expandRowRequestedSource;
    expandRowRequested: rxjs.Observable<any>;
    private collapseRowRequestedSource;
    collapseRowRequested: rxjs.Observable<any>;
    requestExpandRow(row: any): void;
    requestCollapseRow(row: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GridService>;
}

declare class NotificationComponent implements OnInit {
    el: ElementRef;
    /**
     * Option to use Notification as standalone.
     * If true, no margin will be set or any border on parent-element.
     * This is for use outside of <vgr-grid />
     */
    standalone: boolean;
    /**
     * This is deprecated and you're encouraged to use "type" instead.
     *
     * @deprecated
     */
    borderColor: 'success' | 'error' | 'warning' | 'info' | 'comment';
    /**
     * Set icon and background-color of notification
     */
    type: 'success' | 'error' | 'warning' | 'info' | 'comment';
    /**
     * Set width of notification
     */
    width: any;
    /**
     * Set min-height of notification.
     */
    height: any;
    /**
     * Remove icon that's otherwise automatically added
     */
    noIcon: boolean;
    listNotification: boolean;
    standaloneNotification: boolean;
    animate: boolean;
    role: string;
    describeBy: string;
    set isAlertNotice(value: boolean);
    constructor(el: ElementRef);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "vgr-notification", never, { "standalone": { "alias": "standalone"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; "type": { "alias": "type"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "noIcon": { "alias": "noIcon"; "required": false; }; "isAlertNotice": { "alias": "isAlertNotice"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class GridRowComponent implements OnChanges, AfterContentInit, OnDestroy {
    private gridService;
    el: ElementRef;
    expanded: boolean;
    preventCollapse: boolean;
    expandedChanged: EventEmitter<any>;
    expandPrevented: EventEmitter<any>;
    collapsePrevented: EventEmitter<any>;
    gridRowHeader: ElementRef;
    content: QueryList<GridContentComponent>;
    notifications: QueryList<NotificationComponent>;
    zebraLayout: boolean;
    animationSpeed: string;
    hasExpandablecontent: boolean;
    hasNotifications: boolean;
    isExpanded: boolean;
    notificationColor: string;
    overflow: boolean;
    private ngUnsubscribe;
    constructor(gridService: GridService, el: ElementRef);
    get expandedState(): {
        value: boolean;
        params: {
            speed: string;
        };
    };
    ngOnChanges(changes: SimpleChanges): void;
    toggleExpanded(): void;
    toggleState(state: 'start' | 'done', expanded: boolean): void;
    setExpanded(expanded: boolean): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridRowComponent, "vgr-grid-row", never, { "expanded": { "alias": "expanded"; "required": false; }; "preventCollapse": { "alias": "preventCollapse"; "required": false; }; }, { "expandedChanged": "expandedChanged"; "expandPrevented": "expandPrevented"; "collapsePrevented": "collapsePrevented"; }, ["content", "notifications"], ["vgr-grid-column", "vgr-notification", "vgr-grid-content"], false, never>;
}

declare class GridHeaderToolbarComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<GridHeaderToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridHeaderToolbarComponent, "vgr-grid-header-toolbar", never, {}, {}, never, ["*"], false, never>;
}

declare class GridComponent implements OnInit, AfterContentInit, OnDestroy {
    private pageHeaderHeightService;
    private gridService;
    allowMultipleExpandedRows: boolean;
    stickyHeader: boolean;
    toggleAnimation: 'none' | 'slow' | 'medium' | 'fast';
    pages: number;
    activePage: number;
    showLoader: boolean;
    ariaLabel: string;
    increaseHeaderWidth: boolean;
    zebraLayout: boolean;
    pageChanged: EventEmitter<number>;
    sortChanged: EventEmitter<GridSortChangedArgs>;
    gridHeaderToolbar: GridHeaderToolbarComponent;
    gridHeader: GridHeaderComponent;
    rows: QueryList<GridRowComponent>;
    headerOffset: string;
    hasToolbar: boolean;
    private animationSpeed;
    private headerHeight;
    private ngUnsubscribe;
    keydown(event: any): void;
    setFocusOnRow(index: any): void;
    constructor(pageHeaderHeightService: PageHeaderHeightService, gridService: GridService);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    setLayout(): void;
    setAnimationSpeed(): void;
    onPageChanged(event: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridComponent, "vgr-grid", never, { "allowMultipleExpandedRows": { "alias": "allowMultipleExpandedRows"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "toggleAnimation": { "alias": "toggleAnimation"; "required": false; }; "pages": { "alias": "pages"; "required": false; }; "activePage": { "alias": "activePage"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "increaseHeaderWidth": { "alias": "increaseHeaderWidth"; "required": false; }; "zebraLayout": { "alias": "zebraLayout"; "required": false; }; }, { "pageChanged": "pageChanged"; "sortChanged": "sortChanged"; }, ["gridHeaderToolbar", "gridHeader", "rows"], ["vgr-grid-header-toolbar", "vgr-grid-header", "vgr-notification", "vgr-grid-row"], false, never>;
}

declare class GridColumnComponent {
    width: number;
    align: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridColumnComponent, "vgr-grid-column", never, { "width": { "alias": "width"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class EditableTableService {
    private editmode;
    constructor();
    editmodeChanged: rxjs.Observable<any>;
    changeEditmode(value: boolean, id: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTableService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EditableTableService>;
}

declare class EditableTableHeaderColumnComponent implements OnInit, AfterContentInit {
    elem: ElementRef;
    private editableTableService;
    align: string;
    width: any;
    id: string;
    role: string;
    pointer: string;
    editMode: boolean;
    sortKey: string;
    sortDirection: GridSortDirection;
    sortChanged: EventEmitter<GridSortDirection>;
    parentId: string;
    constructor(elem: ElementRef, editableTableService: EditableTableService);
    onClick(target: any): void;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    setPointer(): void;
    changeSort(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTableHeaderColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTableHeaderColumnComponent, "vgr-editable-table-header-column", never, { "align": { "alias": "align"; "required": false; }; "width": { "alias": "width"; "required": false; }; "sortKey": { "alias": "sortKey"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; }, { "sortChanged": "sortChanged"; }, never, ["*"], false, never>;
}

declare class EditableTableHeaderComponent implements AfterContentInit, OnDestroy {
    private ngUnsubscribe;
    sortChanged: EventEmitter<SortChangedArgs>;
    headerColumns: QueryList<EditableTableHeaderColumnComponent>;
    constructor();
    ngAfterContentInit(): void;
    onColumnSortChanged(column: EditableTableHeaderColumnComponent, direction: GridSortDirection): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTableHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTableHeaderComponent, "vgr-editable-table-header", never, {}, { "sortChanged": "sortChanged"; }, ["headerColumns"], ["vgr-editable-table-header-column"], false, never>;
}

declare class EditableTableColumnComponent {
    private el;
    align: string;
    tabIndex: number;
    editMode: any;
    headerId: string;
    role: string;
    constructor(el: ElementRef);
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTableColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTableColumnComponent, "vgr-editable-table-column", never, { "headerId": { "alias": "headerId"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class EditableTableRowComponent implements AfterContentInit {
    elem: ElementRef;
    private editableTableService;
    columns: QueryList<EditableTableColumnComponent>;
    parentId: string;
    role: string;
    set editMode(value: boolean);
    constructor(elem: ElementRef, editableTableService: EditableTableService);
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTableRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTableRowComponent, "vgr-editable-table-row", never, { "parentId": { "alias": "parentId"; "required": false; }; }, {}, ["columns"], ["*"], false, never>;
}

declare class EditableTableComponent implements AfterViewInit, AfterContentInit, OnDestroy {
    elRef: ElementRef;
    private editableTableService;
    set editMode(value: boolean);
    height: string;
    sortChanged: EventEmitter<SortChangedArgs>;
    tableHeader: EditableTableHeaderComponent;
    tableRows: QueryList<EditableTableRowComponent>;
    header: ElementRef;
    currentRow: number;
    currentColumn: number;
    inEditmode: boolean;
    calculatedHeight: any;
    editableTableClass: boolean;
    id: string;
    onFocus(event: any): void;
    resetTabIndexOnColumn(): void;
    setTabIndexAndFocusOnColumn(): void;
    onKeydownHandler(event: any): void;
    setColumnWidths(): void;
    constructor(elRef: ElementRef, editableTableService: EditableTableService);
    private ngUnsubscribe;
    ngAfterViewInit(): void;
    calculateTableHeight(): void;
    ngAfterContentInit(): void;
    setAlignment(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTableComponent, "vgr-editable-table", never, { "editMode": { "alias": "editMode"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, { "sortChanged": "sortChanged"; }, ["tableHeader", "tableRows"], ["vgr-editable-table-header", "vgr-editable-table-row"], false, never>;
}

declare class CheckboxGroupComponent implements ControlValueAccessor, AfterContentInit, OnChanges, OnDestroy {
    private controlContainer;
    private elementRef;
    _disabled: boolean;
    showValidation: boolean;
    set disabled(val: any);
    vertical: boolean;
    formControlName?: string;
    required: boolean;
    selectedChanged: EventEmitter<CheckboxComponent>;
    items: QueryList<CheckboxComponent>;
    ngUnsubscribeItems: any;
    validationErrorMessage: string;
    elementId: string;
    _value: string[];
    control: AbstractControl;
    constructor(controlContainer: ControlContainer, elementRef: ElementRef);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: any): void;
    keyDown(event: KeyboardEvent): void;
    getLabelFromId(): HTMLLabelElement;
    get errorActive(): any;
    setGroupDisabledOverride(groupDisabledState: boolean): void;
    onChange(value: any): void;
    onTouch: (value: any) => void;
    onLeave(event: any): void;
    writeValue(event: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroupComponent, [{ optional: true; host: true; skipSelf: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxGroupComponent, "vgr-checkbox-group", never, { "showValidation": { "alias": "showValidation"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "selectedChanged": "selectedChanged"; }, ["items"], ["vgr-checkbox"], false, never>;
}

declare class SelectablelistHeaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectablelistHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectablelistHeaderComponent, "vgr-selectablelist-header", never, {}, {}, never, ["vgr-selectablelist-header-column"], false, never>;
}

declare class SelectablelistService {
    private clickedRowRequestedSource;
    private clickedHeaderRequestedSource;
    clickedRowRequested: rxjs.Observable<any>;
    clickedHeaderRequested: rxjs.Observable<any>;
    requestRowClicked(row: any): void;
    headerClicked(header: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectablelistService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectablelistService>;
}

declare class SelectablelistRowComponent implements OnInit {
    elem: ElementRef;
    private selectablelistService;
    rowClicked: EventEmitter<any>;
    value: any;
    groupheader: boolean;
    selectable: boolean;
    selected: boolean;
    focused: boolean;
    role: string;
    id: string;
    toggleSelected(): void;
    constructor(elem: ElementRef, selectablelistService: SelectablelistService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectablelistRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectablelistRowComponent, "vgr-selectablelist-row", never, { "value": { "alias": "value"; "required": false; }; "groupheader": { "alias": "groupheader"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; }, { "rowClicked": "rowClicked"; }, never, ["*"], false, never>;
}

declare class SelectablelistComponent implements AfterContentInit, OnChanges, OnDestroy {
    elRef: ElementRef;
    private selectablelistService;
    headersPresent: boolean;
    controlPressed: boolean;
    focusedRow: number;
    sortOption: {
        column: number;
        sortDirection: GridSortDirection;
    };
    sortDirection: typeof GridSortDirection;
    activeDecendant: any;
    role: string;
    multi: boolean;
    tabIndex: number;
    active: boolean;
    setFirstSelectable: boolean;
    useScrollbar: boolean;
    maxHeight: number;
    id: string;
    selectedChanged: EventEmitter<any>;
    header: SelectablelistHeaderComponent;
    rows: QueryList<SelectablelistRowComponent>;
    scrollWrapper: any;
    scrollable: ScrollbarComponent;
    private ngUnsubscribe;
    lastSelectedItemIndex: number;
    isClicked: boolean;
    showScrollbar: boolean;
    onKeydownHandler(event: KeyboardEvent): void;
    onClick(event: any): void;
    onCompFocus(event: any): void;
    onCompBlur(event: any): void;
    alignColumns(): void;
    constructor(elRef: ElementRef, selectablelistService: SelectablelistService);
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterContentInit(): void;
    setScrollbarOnHeightChange(): void;
    handleRowClicked(row: SelectablelistRowComponent): void;
    setInternalIds(): void;
    clearSelection(): void;
    selectFirstSelectable(): void;
    focusRow(index: any): void;
    isRowVisible(id: any): boolean;
    changeActiveStatus(index: any, setFocus?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectablelistComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectablelistComponent, "vgr-selectablelist", never, { "active": { "alias": "active"; "required": false; }; "setFirstSelectable": { "alias": "setFirstSelectable"; "required": false; }; "useScrollbar": { "alias": "useScrollbar"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "selectedChanged": "selectedChanged"; }, ["header", "rows"], ["vgr-selectablelist-header", "vgr-selectablelist-row"], false, never>;
}

declare class SelectablelistHeaderColumnComponent implements OnInit {
    elem: ElementRef;
    private selectablelistService;
    alignRight: boolean;
    alignCenter: boolean;
    id: string;
    toggleSelected(): void;
    constructor(elem: ElementRef, selectablelistService: SelectablelistService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectablelistHeaderColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectablelistHeaderColumnComponent, "vgr-selectablelist-header-column", never, { "alignRight": { "alias": "alignRight"; "required": false; }; "alignCenter": { "alias": "alignCenter"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class SelectablelistColumnComponent {
    alignRight: boolean;
    alignCenter: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectablelistColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectablelistColumnComponent, "vgr-selectablelist-column", never, { "alignRight": { "alias": "alignRight"; "required": false; }; "alignCenter": { "alias": "alignCenter"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class Guid {
    static newGuid(): string;
}

declare class SubmenuComponent extends MenuItemBaseDirective implements AfterContentInit, OnInit, OnDestroy {
    private router;
    private elementRef;
    private renderer;
    text: string;
    private _showExpanded;
    private ngUnsubscribe;
    state: string;
    hasAriaPopup: string;
    role: string;
    expanded: boolean;
    ToggleChanged: EventEmitter<any>;
    menuItems: QueryList<MenuItemComponent>;
    hasClass: boolean;
    childSelected: boolean;
    menuitem: ElementRef;
    onKeyDown(event: KeyboardEvent): void;
    get expandedState(): boolean;
    set expandedState(show: boolean);
    toggleExpand(): void;
    constructor(router: Router, elementRef: ElementRef, renderer: Renderer2);
    animationDone(event: any): void;
    setFocus(handle?: boolean): void;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    addSubscriptions(): void;
    private setChildSelected;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubmenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubmenuComponent, "vgr-submenu", never, { "text": { "alias": "text"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; }, { "ToggleChanged": "ToggleChanged"; }, ["menuItems"], ["*"], false, never>;
}

declare class SidebarMenuComponent implements AfterContentInit {
    subMenu: SubmenuComponent;
    constructor();
    addHeight(): void;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarMenuComponent, "vgr-sidebar-menu", never, {}, {}, ["subMenu"], ["*"], false, never>;
}

declare class IconModule {
    constructor(library: FaIconLibrary);
    static ɵfac: i0.ɵɵFactoryDeclaration<IconModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IconModule, never, [typeof i1.FontAwesomeModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IconModule>;
}

declare class KomponentkartanModule {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<KomponentkartanModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<KomponentkartanModule, [typeof SafePipe, typeof TruncatePipe, typeof FilterPipe, typeof ErrorMessagePipe, typeof HsaidPipe, typeof PersonnummerPipe, typeof PostnummerPipe, typeof CurrencyPipe, typeof ActionPanelComponent, typeof ButtonComponent, typeof LockButtonComponent, typeof SaveCancelComponent, typeof PageHeaderComponent, typeof RadioGroupComponent, typeof HeaderComponent, typeof LoginInformationComponent, typeof HeaderMenuComponent, typeof CheckboxComponent, typeof ModalPlaceholderComponent, typeof ModalContentComponent, typeof ModalHeaderComponent, typeof ModalFooterComponent, typeof CardComponent, typeof CardHeaderComponent, typeof CardColumnComponent, typeof CardSectionComponent, typeof TitleValueComponent, typeof TitleValueLayoutComponent, typeof TitleValueHeadingComponent, typeof TitleValueContainerComponent, typeof LoaderComponent, typeof SkeletonLoaderComponent, typeof PageComponent, typeof PageBodyComponent, typeof PageBlockComponent, typeof SidebarMenuComponent, typeof MenuComponent, typeof MenuItemComponent, typeof MenuSeparatorComponent, typeof ExpandableDivComponent, typeof ExpandableDivHeaderComponent, typeof ExpandableDivContentComponent, typeof PanelComponent, typeof PanelContainerComponent, typeof SubmenuComponent, typeof CloseButtonComponent, typeof TableRowColumnComponent, typeof TableHeaderColumnComponent, typeof TableHeaderComponent, typeof TableRowComponent, typeof TableComponent, typeof TextareaComponent, typeof FilterTagComponent, typeof FilterTagGroupComponent, typeof RingWithTextComponent, typeof ScrollToTopComponent, typeof ToggleButtonComponent, typeof ToggleButtonGroupComponent, typeof SearchResultComponent, typeof DropdownItemComponent, typeof PaginationComponent, typeof DropdownSelectComponent, typeof IconComponent, typeof DatepickerComponent, typeof DatepickerItemComponent, typeof GridComponent, typeof GridHeaderComponent, typeof GridHeaderColumnComponent, typeof GridColumnComponent, typeof GridRowComponent, typeof GridContentComponent, typeof GridHeaderToolbarComponent, typeof NotificationComponent, typeof InputComponent, typeof SortArrowComponent, typeof TabButtonComponent, typeof TabButtonGroupComponent, typeof ComboboxComponent, typeof ComboboxItemComponent, typeof ScrollbarComponent, typeof EditableTableComponent, typeof EditableTableHeaderColumnComponent, typeof EditableTableHeaderComponent, typeof EditableTableRowComponent, typeof EditableTableColumnComponent, typeof RadiobuttonGroupComponent, typeof RadiobuttonItemComponent, typeof CheckboxGroupComponent, typeof SelectablelistComponent, typeof SelectablelistHeaderComponent, typeof SelectablelistColumnComponent, typeof SelectablelistHeaderColumnComponent, typeof SelectablelistRowComponent], [typeof i94.FormsModule, typeof i95.RouterModule, typeof i96.NgScrollbarModule, typeof i97.CommonModule, typeof i94.ReactiveFormsModule, typeof IconModule, typeof i1.FontAwesomeModule], [typeof SafePipe, typeof TruncatePipe, typeof FilterPipe, typeof ErrorMessagePipe, typeof HsaidPipe, typeof PersonnummerPipe, typeof PostnummerPipe, typeof CurrencyPipe, typeof ActionPanelComponent, typeof ButtonComponent, typeof LockButtonComponent, typeof SaveCancelComponent, typeof PageHeaderComponent, typeof RadioGroupComponent, typeof HeaderComponent, typeof LoginInformationComponent, typeof HeaderMenuComponent, typeof CheckboxComponent, typeof ModalPlaceholderComponent, typeof ModalContentComponent, typeof ModalHeaderComponent, typeof ModalFooterComponent, typeof CardComponent, typeof CardHeaderComponent, typeof CardColumnComponent, typeof CardSectionComponent, typeof TitleValueComponent, typeof TitleValueLayoutComponent, typeof TitleValueHeadingComponent, typeof TitleValueContainerComponent, typeof LoaderComponent, typeof SkeletonLoaderComponent, typeof PageComponent, typeof PageBodyComponent, typeof PageBlockComponent, typeof MenuComponent, typeof SidebarMenuComponent, typeof MenuItemComponent, typeof MenuSeparatorComponent, typeof ExpandableDivComponent, typeof ExpandableDivHeaderComponent, typeof ExpandableDivContentComponent, typeof PanelComponent, typeof PanelContainerComponent, typeof SubmenuComponent, typeof CloseButtonComponent, typeof TableComponent, typeof TableRowColumnComponent, typeof TableHeaderColumnComponent, typeof TableHeaderComponent, typeof TableRowComponent, typeof TextareaComponent, typeof FilterTagComponent, typeof RingWithTextComponent, typeof FilterTagGroupComponent, typeof ScrollToTopComponent, typeof ToggleButtonComponent, typeof ToggleButtonGroupComponent, typeof SearchResultComponent, typeof DropdownItemComponent, typeof PaginationComponent, typeof DropdownSelectComponent, typeof IconComponent, typeof DatepickerComponent, typeof DatepickerItemComponent, typeof GridComponent, typeof GridHeaderComponent, typeof GridHeaderColumnComponent, typeof GridColumnComponent, typeof GridRowComponent, typeof GridContentComponent, typeof GridHeaderToolbarComponent, typeof NotificationComponent, typeof InputComponent, typeof SortArrowComponent, typeof TabButtonComponent, typeof TabButtonGroupComponent, typeof ComboboxComponent, typeof ComboboxItemComponent, typeof ScrollbarComponent, typeof EditableTableComponent, typeof EditableTableHeaderColumnComponent, typeof EditableTableHeaderComponent, typeof EditableTableRowComponent, typeof EditableTableColumnComponent, typeof RadiobuttonGroupComponent, typeof RadiobuttonItemComponent, typeof CheckboxGroupComponent, typeof SelectablelistComponent, typeof SelectablelistHeaderComponent, typeof SelectablelistColumnComponent, typeof SelectablelistHeaderColumnComponent, typeof SelectablelistRowComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<KomponentkartanModule>;
}

export { ActionPanelComponent, BrowserDetector, ButtonComponent, CardColumnComponent, CardComponent, CardHeaderComponent, CardSectionComponent, CheckboxComponent, CheckboxGroupComponent, CloseButtonComponent, ComboboxComponent, ComboboxItemComponent, CurrencyPipe, DatepickerComponent, DatepickerItemComponent, DropdownItemComponent, DropdownSelectComponent, EditableTableColumnComponent, EditableTableComponent, EditableTableHeaderColumnComponent, EditableTableHeaderComponent, EditableTableRowComponent, ErrorMessagePipe, ExpandableDivComponent, ExpandableDivContentComponent, ExpandableDivHeaderComponent, ExpandableRow, FilterPipe, FilterTagComponent, FilterTagGroupComponent, GridColumnComponent, GridComponent, GridContentComponent, GridHeaderColumnComponent, GridHeaderComponent, GridHeaderToolbarComponent, GridRowComponent, GridSortDirection, Guid, HeaderComponent, HeaderMenuComponent, HsaidPipe, IconComponent, InputComponent, KomponentkartanModule, LoaderComponent, LockButtonComponent, LoginInformationComponent, MenuComponent, MenuItemComponent, MenuSeparatorComponent, ModalContentComponent, ModalFooterComponent, ModalHeaderComponent, ModalPlaceholderComponent, ModalService, NotificationComponent, NotificationType, PageBlockComponent, PageBodyComponent, PageComponent, PageHeaderComponent, PaginationComponent, PaginationManagementService, PanelComponent, PanelContainerComponent, PersonnummerPipe, PostnummerPipe, RadioGroupComponent, RadiobuttonGroupComponent, RadiobuttonItemComponent, RingWithTextComponent, SafePipe, SaveCancelComponent, ScrollToTopComponent, ScrollbarComponent, SearchResultComponent, SelectablelistColumnComponent, SelectablelistComponent, SelectablelistHeaderColumnComponent, SelectablelistHeaderComponent, SelectablelistRowComponent, SelectablelistService, SidebarMenuComponent, SkeletonLoaderComponent, SortArrowComponent, SubmenuComponent, TabButtonComponent, TabButtonGroupComponent, TabManagementService, TableComponent, TableHeaderColumnComponent, TableHeaderComponent, TableRowColumnComponent, TableRowComponent, TextareaComponent, TitleValueComponent, TitleValueContainerComponent, TitleValueHeadingComponent, TitleValueLayoutComponent, ToggleButtonComponent, ToggleButtonGroupComponent, TruncatePipe };
export type { GridSortChangedArgs, ISelectableItem, Notification, RowNotification, SearchResultItem, SelectableItem, SortChangedArgs };