import * as i0 from '@angular/core';
import { EventEmitter, OnInit, ChangeDetectorRef, ElementRef, AfterViewInit, AfterContentInit, AfterViewChecked, OnDestroy, QueryList, OnChanges, SimpleChanges, Renderer2, TemplateRef, DoCheck, ModuleWithProviders, InjectionToken, ComponentRef, Type, Signal, ViewContainerRef, PipeTransform, DebugElement } from '@angular/core';
import { ControlValueAccessor, ValidatorFn, ControlContainer, FormGroup, FormControl, ValidationErrors, AbstractControl, UntypedFormControl, FormGroupDirective, NgForm, UntypedFormGroup } from '@angular/forms';
import { MatButtonToggleChange } from '@angular/material/button-toggle';
import * as rxjs from 'rxjs';
import { Observable, Subscription, Subject, ReplaySubject, BehaviorSubject } from 'rxjs';
import { MatTooltip, TooltipPosition } from '@angular/material/tooltip';
import { MatBadge } from '@angular/material/badge';
import { MatRipple, NativeDateAdapter, MatOption, ErrorStateMatcher } from '@angular/material/core';
import { PageEvent, MatPaginator, MatPaginatorIntl } from '@angular/material/paginator';
import { MatTableDataSource } from '@angular/material/table';
import { MatSort, Sort } from '@angular/material/sort';
import { TranslocoService } from '@jsverse/transloco';
import * as i1 from '@angular/common';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpClient, HttpParams, HttpInterceptorFn } from '@angular/common/http';
import { MatAutocompleteTrigger, MatAutocomplete, MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import { MatChip } from '@angular/material/chips';
import { MatDatepicker, MatDateSelectionModel, DateFilterFn } from '@angular/material/datepicker';
import { ScrollStrategy, OverlayRef } from '@angular/cdk/overlay';
import { ComponentType, ComponentPortal } from '@angular/cdk/portal';
import { LiveAnnouncer, FocusableOption } from '@angular/cdk/a11y';
import { MatDialogRef } from '@angular/material/dialog';
import { MatSelect, MatSelectChange } from '@angular/material/select';
import { MatSlider } from '@angular/material/slider';
import * as _angular_animations from '@angular/animations';
import { MatAccordionDisplayMode, MatAccordionTogglePosition, MatAccordion, MatExpansionPanel } from '@angular/material/expansion';
import { MatTabChangeEvent } from '@angular/material/tabs';
import * as _ihk_gfi_lux_components from '@ihk-gfi/lux-components';
import { StepperSelectionEvent, CdkStepHeader } from '@angular/cdk/stepper';
import { MatStepper } from '@angular/material/stepper';
import { MatSnackBarRef, MatSnackBarDismiss } from '@angular/material/snack-bar';
import { ComponentFixture } from '@angular/core/testing';

declare type LuxThemePalette = 'primary' | 'accent' | 'warn' | undefined;
declare type LuxFgColor = 'white' | 'black';
declare type LuxBgBaseColor = 'red' | 'green' | 'purple' | 'blue' | 'gray' | 'orange' | 'yellow' | 'pink' | 'lightblue';
declare type LuxBgAllColor = LuxBgBaseColor | 'black' | 'white';
declare type LuxBadgeColor = LuxBgBaseColor | 'black';
declare type LuxIconColor = LuxBgBaseColor | 'black';
declare type LuxMessageBoxColor = LuxBgBaseColor | 'white';
declare type LuxProgressColor = LuxBgBaseColor;
declare type LuxSnackbarColor = LuxBgBaseColor | 'white';
declare type LuxTextboxColor = 'red' | 'blue' | 'green' | 'yellow';
declare type LuxAccordionColor = 'primary' | 'accent' | 'warn' | 'neutral';
declare const LuxBgAllColors: LuxBgAllColor[];
declare const LuxBadgeColors: LuxBadgeColor[];
declare const LuxIconColors: LuxIconColor[];
declare const LuxMessageBoxColors: LuxMessageBoxColor[];
declare const LuxProgressColors: LuxProgressColor[];
declare const LuxSnackbarColors: LuxSnackbarColor[];
declare const LuxTextboxColors: LuxTextboxColor[];
declare const LuxAccordionColors: LuxAccordionColor[];

/**
 * Base-Klasse der LuxActionComponents.
 *
 * Enthält die Inputs/Outputs, die allen Action-Components gleich sind.
 */
declare class LuxActionComponentBaseClass {
    luxLabel?: string | undefined;
    luxColor?: LuxThemePalette;
    luxRaised?: boolean | undefined;
    luxIconName?: string | undefined;
    luxIconShowRight?: boolean | undefined;
    luxTagId?: string;
    luxDisabled?: boolean | undefined;
    luxRounded?: boolean | undefined;
    luxFlat?: boolean | undefined;
    luxStroked?: boolean | undefined;
    luxClicked: EventEmitter<Event>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxActionComponentBaseClass, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxActionComponentBaseClass, never, never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; "luxRaised": { "alias": "luxRaised"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxIconShowRight": { "alias": "luxIconShowRight"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxRounded": { "alias": "luxRounded"; "required": false; }; "luxFlat": { "alias": "luxFlat"; "required": false; }; "luxStroked": { "alias": "luxStroked"; "required": false; }; }, { "luxClicked": "luxClicked"; }, never, never, true, never>;
}

interface LuxButtonToggleOption<T = unknown> {
    label: string;
    value: T;
    disabled?: boolean;
    ariaLabel?: string;
}
declare class LuxButtonToggleComponent<T = unknown> implements ControlValueAccessor, OnInit {
    private static nextUniqueId;
    private readonly cdr;
    private readonly destroyRef;
    private readonly injector;
    private readonly controlContainer;
    private readonly uniqueId;
    private readonly tService;
    private readonly defaultAriaLabel;
    readonly luxDense: i0.InputSignal<boolean>;
    readonly luxAriaLabel: i0.InputSignal<string | undefined>;
    readonly luxOptions: i0.InputSignal<LuxButtonToggleOption<T>[]>;
    readonly luxMultiple: i0.InputSignal<boolean>;
    readonly luxDisabled: i0.InputSignal<boolean>;
    readonly luxRequired: i0.InputSignal<boolean>;
    readonly luxHint: i0.InputSignal<string | undefined>;
    readonly luxError: i0.InputSignal<string | undefined>;
    readonly luxControlBinding: i0.InputSignal<string | undefined>;
    readonly luxCompareWith: i0.InputSignal<(a: T, b: T) => boolean>;
    readonly hintElementId: string;
    readonly errorElementId: string;
    readonly luxSelected: i0.ModelSignal<T | undefined>;
    readonly luxSelectedValues: i0.ModelSignal<T[]>;
    private onChange;
    private onTouched;
    private writingValue;
    private cvaDisabled;
    private touched;
    private ngControl;
    private ngControlResolved;
    private boundFormControl;
    constructor();
    ngOnInit(): void;
    get hasMinimumOptions(): boolean;
    get isDisabled(): boolean;
    get hasError(): boolean;
    get shouldShowError(): boolean;
    get errorMessage(): string | undefined;
    get hintMessage(): string | undefined;
    get ariaLabel(): string;
    isChecked(value: T): boolean;
    onSingleSelectionChange(event: MatButtonToggleChange): void;
    onMultipleSelectionChange(value: T, checked: boolean): void;
    writeValue(value: T | T[] | null): void;
    registerOnChange(fn: (value: T | T[] | undefined) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    markAsTouched(): void;
    private validateMinimumOptions;
    private syncSelectionToMode;
    private normalizeSingleSelectionToOption;
    private emitCvaValue;
    private hasSelection;
    private isRequiredMissingSelection;
    private hasRequiredError;
    private isFormInvalid;
    private isTouchedOrDirty;
    private getNgControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxButtonToggleComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxButtonToggleComponent<any>, "lux-button-toggle", never, { "luxDense": { "alias": "luxDense"; "required": false; "isSignal": true; }; "luxAriaLabel": { "alias": "luxAriaLabel"; "required": false; "isSignal": true; }; "luxOptions": { "alias": "luxOptions"; "required": false; "isSignal": true; }; "luxMultiple": { "alias": "luxMultiple"; "required": false; "isSignal": true; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; "isSignal": true; }; "luxRequired": { "alias": "luxRequired"; "required": false; "isSignal": true; }; "luxHint": { "alias": "luxHint"; "required": false; "isSignal": true; }; "luxError": { "alias": "luxError"; "required": false; "isSignal": true; }; "luxControlBinding": { "alias": "luxControlBinding"; "required": false; "isSignal": true; }; "luxCompareWith": { "alias": "luxCompareWith"; "required": false; "isSignal": true; }; "luxSelected": { "alias": "luxSelected"; "required": false; "isSignal": true; }; "luxSelectedValues": { "alias": "luxSelectedValues"; "required": false; "isSignal": true; }; }, { "luxSelected": "luxSelectedChange"; "luxSelectedValues": "luxSelectedValuesChange"; }, never, never, true, never>;
}

declare type LuxProgressModeType = 'determinate' | 'indeterminate';
declare type LuxProgressType = 'Progressbar' | 'Spinner';
declare type LuxProgressSizeType = 'small' | 'medium' | 'large';
declare class LuxProgressComponent {
    readonly DEFAULT_PROGRESS_COLOR: LuxProgressColor;
    private _luxMode?;
    private _luxType?;
    private _luxColor?;
    animDurationCSS: string;
    typeCSS: string;
    luxValue: number;
    luxAriaLabel: string;
    luxSize: LuxProgressSizeType;
    luxTagId?: string;
    set luxColor(value: LuxProgressColor | undefined);
    get luxColor(): LuxProgressColor | undefined;
    set luxMode(mode: LuxProgressModeType);
    get luxMode(): LuxProgressModeType;
    set luxType(type: LuxProgressType | undefined);
    get luxType(): LuxProgressType | undefined;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxProgressComponent, "lux-progress", never, { "luxValue": { "alias": "luxValue"; "required": false; }; "luxAriaLabel": { "alias": "luxAriaLabel"; "required": false; }; "luxSize": { "alias": "luxSize"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; "luxMode": { "alias": "luxMode"; "required": false; }; "luxType": { "alias": "luxType"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Interface, welches die Konfigurationsoptionen für die LuxComponents bereitstellt.
 */
interface LuxComponentsConfigParameters {
    /**
     * Bestimmt den Basepfad der Icons.
     */
    iconBasePath?: string;
    /**
     * Bestimmt, ob die LuxTagIds (und dazugehörende) Warnungen generiert werden.
     */
    generateLuxTagIds?: boolean;
    /**
     * Bestimmt, ob die Ausgaben des LuxConsoleService in die Developer-Console des Browsers geschrieben werden.
     */
    displayLuxConsoleLogs?: boolean;
    /**
     * Bestimmt die URL des Lookup-Services für die LookupComponents.
     */
    lookupServiceUrl?: string;
    /**
     * Bestimmt die URL des Lookup-Services für die TenantLogoComponents.
     */
    tenantLogoLookupServiceUrl?: string;
    /**
     * Bestimmt, ob die Labels für LuxButtons, LuxLinks, LuxMenuItems, LuxStepper, LuxSideNavItem und LuxTabs
     * immer Uppercase dargestellt werden.
     */
    labelConfiguration?: {
        /**
         * Alle Labels Uppercase darstellen
         */
        allUppercase: boolean;
        /**
         * Ausnahmen eintragen (die Sektoren in das Array eintragen; z.B. lux-link)
         */
        notAppliedTo: string[];
    };
    /**
     * Flag, um die Animationen von LUX-Cards zu aktivieren bzw. zu deaktivieren
     */
    cardExpansionAnimationActive?: boolean;
    /**
     * Bestimmt die globalen Einstellungen für die Animationen der LuxRipples.
     */
    rippleConfiguration?: {
        enterDuration: number;
        exitDuration: number;
        color?: string;
        centered?: boolean;
        radius?: number;
        disabled?: boolean;
        unbounded?: boolean;
    };
    /**
     * Bestimmt die globalen Einstellungen für die Buttons.
     */
    buttonConfiguration?: {
        throttleTimeMs?: number;
    };
    viewConfiguration?: {
        centeredView?: boolean;
        centeredWidth?: string;
    };
    appFooter?: {
        fixedDesktop?: boolean;
        fixedMobile?: boolean;
    };
    sessionTimerConfig?: {
        url?: string;
        httpSessionTimeHeaderName?: string;
        httpSessionProlongationHeaderName?: string;
    };
}

/**
 * Dieser Service wird dazu verwendet, auf die Konfiguration der LuxComponents zuzugreifen und diese auszulesen bzw.
 * auch zu aktualisieren.
 */
declare class LuxComponentsConfigService {
    static readonly DEFAULT_CONFIG: {
        iconBasePath: string;
        displayLuxConsoleLogs: boolean;
        generateLuxTagIds: boolean;
        lookupServiceUrl: string;
        tenantLogoLookupServiceUrl: string;
        labelConfiguration: {
            allUppercase: boolean;
            notAppliedTo: never[];
        };
        cardExpansionAnimationActive: boolean;
        rippleConfiguration: {
            exitDuration: number;
            enterDuration: number;
        };
        buttonConfiguration: {
            throttleTimeMs: number;
        };
        viewConfiguration: {
            centeredView: boolean;
            centeredWidth: string;
        };
        appFooter: {
            fixedDesktop: boolean;
            fixedMobile: boolean;
        };
    };
    private config$;
    /**
     * Gibt das Observable mit der aktuell gesetzten Konfiguration zurück.
     */
    get config(): Observable<LuxComponentsConfigParameters>;
    /**
     * Gibt die aktuell gesetzte Konfiguration direkt zurück.
     */
    get currentConfig(): LuxComponentsConfigParameters;
    constructor();
    /**
     * Gibt zurück, ob die Labels als Uppercase gekennzeichnet sind und ob
     * die übergebenen Selektoren in den Ausnahmen geführt sind.
     * @param selector
     */
    isLabelUppercaseForSelector(selector: string): boolean;
    /**
     * Ersetzt die aktuelle Konfiguration mit der übergebenen (wenn gültiger Wert).
     * @param config
     */
    updateConfiguration(config: LuxComponentsConfigParameters): void;
    /**
     * Kombiniert die übergebene Konfiguration mit der Standard-Konfiguration.
     *
     * Übernimmt die Werte aus der Standard-Konfiguration, die nicht im übergebenen gesetzt wurden.
     * @param config
     */
    private mergeDefaultData;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxComponentsConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxComponentsConfigService>;
}

declare class LuxLinkPlainComponent extends LuxActionComponentBaseClass implements OnInit {
    private router;
    cdr: ChangeDetectorRef;
    tooltipDirective?: LuxTooltipDirective;
    classes: string;
    luxHref: string;
    luxBlank: boolean;
    private _customClass;
    get luxCustomClass(): string;
    set luxCustomClass(customClass: string);
    ngOnInit(): void;
    private updateHostClasses;
    isExternal(): boolean;
    auxClicked(event: MouseEvent): void;
    redirectToHref($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLinkPlainComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLinkPlainComponent, "lux-link-plain", never, { "luxHref": { "alias": "luxHref"; "required": false; }; "luxBlank": { "alias": "luxBlank"; "required": false; }; "luxCustomClass": { "alias": "luxCustomClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxLinkComponent extends LuxActionComponentBaseClass {
    private router;
    cdr: ChangeDetectorRef;
    elementRef: ElementRef<any>;
    componentsConfigService: LuxComponentsConfigService;
    tooltipDirective?: LuxTooltipDirective;
    labelUppercase: boolean;
    readonly iconSize: string;
    luxHref: string;
    luxBlank?: boolean | undefined;
    constructor();
    auxClicked(event: Event): void;
    isExternal(): boolean;
    redirectToHref(event: Event): void;
    isOpenInNewTab(event: Event): boolean;
    private detectParent;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLinkComponent, "lux-link", never, { "luxHref": { "alias": "luxHref"; "required": false; }; "luxBlank": { "alias": "luxBlank"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxDividerComponent {
    luxInset: i0.InputSignal<boolean>;
    luxVertical: i0.InputSignal<boolean>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDividerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDividerComponent, "lux-divider", never, { "luxInset": { "alias": "luxInset"; "required": false; "isSignal": true; }; "luxVertical": { "alias": "luxVertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LuxMenuItemComponent extends LuxActionComponentBaseClass {
    luxButtonTooltip: string;
    luxMenuTooltip: string;
    luxPrio: number;
    luxButtonBadge?: string;
    luxButtonBadgeColor: LuxThemePalette;
    luxMenuItemSubtitle: i0.InputSignal<string>;
    luxMenuItemSelected: i0.InputSignal<boolean>;
    luxHiddenChange: EventEmitter<boolean>;
    luxHideLabelIfExtendedChange: EventEmitter<boolean>;
    luxAlwaysVisibleChange: EventEmitter<boolean>;
    _luxAlwaysVisible: boolean;
    _luxHideLabelIfExtended: boolean;
    _luxHidden: boolean;
    width: number;
    extended: boolean;
    get luxAlwaysVisible(): boolean;
    set luxAlwaysVisible(value: boolean);
    get luxHideLabelIfExtended(): boolean;
    set luxHideLabelIfExtended(value: boolean);
    get luxHidden(): boolean;
    set luxHidden(value: boolean);
    luxClass?: string | string[] | Set<string> | Record<string, any>;
    constructor();
    clicked(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMenuItemComponent, "lux-menu-item", never, { "luxButtonTooltip": { "alias": "luxButtonTooltip"; "required": false; }; "luxMenuTooltip": { "alias": "luxMenuTooltip"; "required": false; }; "luxPrio": { "alias": "luxPrio"; "required": false; }; "luxButtonBadge": { "alias": "luxButtonBadge"; "required": false; }; "luxButtonBadgeColor": { "alias": "luxButtonBadgeColor"; "required": false; }; "luxMenuItemSubtitle": { "alias": "luxMenuItemSubtitle"; "required": false; "isSignal": true; }; "luxMenuItemSelected": { "alias": "luxMenuItemSelected"; "required": false; "isSignal": true; }; "luxAlwaysVisible": { "alias": "luxAlwaysVisible"; "required": false; }; "luxHideLabelIfExtended": { "alias": "luxHideLabelIfExtended"; "required": false; }; "luxHidden": { "alias": "luxHidden"; "required": false; }; "luxClass": { "alias": "luxClass"; "required": false; }; }, { "luxHiddenChange": "luxHiddenChange"; "luxHideLabelIfExtendedChange": "luxHideLabelIfExtendedChange"; "luxAlwaysVisibleChange": "luxAlwaysVisibleChange"; }, never, never, true, never>;
}

declare class LuxMenuPanelHeaderComponent {
    luxTitle: i0.InputSignal<string>;
    luxSubtitle: i0.InputSignal<string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMenuPanelHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMenuPanelHeaderComponent, "lux-menu-panel-header", never, { "luxTitle": { "alias": "luxTitle"; "required": false; "isSignal": true; }; "luxSubtitle": { "alias": "luxSubtitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LuxMenuSectionTitleComponent {
    luxTitle: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMenuSectionTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMenuSectionTitleComponent, "lux-menu-section-title", never, { "luxTitle": { "alias": "luxTitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LuxMenuTriggerComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMenuTriggerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMenuTriggerComponent, "lux-menu-trigger", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxMenuComponent implements AfterViewInit, AfterContentInit, AfterViewChecked, OnDestroy, OnInit {
    private cdr;
    private themeService;
    protected elementRef: ElementRef<any>;
    private readonly PADDING_PX;
    private readonly MARGIN_PX;
    private readonly ICON_PX;
    private readonly FONT_SIZE;
    private readonly FONT_WEIGHT;
    private readonly FONT_FAMILY;
    private readonly BADGE_SIZE;
    private _menuItems;
    private _menuItemsNotExtended;
    private readonly canvas;
    private menuItemSubscriptions;
    private menuItemChangeSubscription;
    hideToggle: boolean;
    triggerButtonDivEl?: HTMLElement;
    customTriggerEl?: HTMLElement;
    defaultTriggerElRef?: ElementRef;
    defaultTriggerComponent?: LuxButtonComponent;
    menuTriggerElRef?: ElementRef;
    menuExtendedContainer: ElementRef;
    luxMenuItemComponents: QueryList<LuxMenuItemComponent>;
    menuNotExtendedPanel: QueryList<LuxMenuItemComponent | LuxDividerComponent | LuxMenuPanelHeaderComponent | LuxMenuSectionTitleComponent>;
    luxMenuTriggerComponent?: LuxMenuTriggerComponent;
    luxMenuClosed: EventEmitter<void>;
    luxMenuOpened: EventEmitter<void>;
    luxMenuLabel: string;
    luxMenuIconName: string;
    luxMenuTriggerIconShowRight: boolean;
    luxMenuItemFixWidth: number;
    luxClassName: string;
    luxTagId?: string;
    luxToggleDisabled: boolean;
    luxAriaMenuTriggerLabel: string;
    luxShowSections: i0.InputSignal<boolean>;
    luxMenuPanelLarge: i0.InputSignal<boolean>;
    _luxDisplayExtended: boolean;
    visibleMenuItems: LuxMenuItemComponent[];
    tooltipDirective?: LuxTooltipDirective;
    get luxDisplayExtended(): boolean;
    set luxDisplayExtended(value: boolean);
    luxDisplayMenuLeft: boolean;
    luxMaximumExtended: number;
    windowResize(): void;
    get menuItems(): LuxMenuItemComponent[];
    set menuItems(menuItems: LuxMenuItemComponent[]);
    get menuItemsNotExtended(): (LuxMenuItemComponent | LuxDividerComponent | LuxMenuPanelHeaderComponent | LuxMenuSectionTitleComponent)[];
    set menuItemsNotExtended(menuItems: (LuxMenuItemComponent | LuxDividerComponent | LuxMenuPanelHeaderComponent | LuxMenuSectionTitleComponent)[]);
    constructor();
    ngAfterViewInit(): void;
    ngOnInit(): void;
    onTrigger(): void;
    ngAfterContentInit(): void;
    addMenuElementsToArray(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    /**
     * Wird beim Klick auf ein MenuItem aufgerufen.
     * @param menuItem
     * @param event
     */
    menuItemClicked(menuItem: LuxMenuItemComponent, event: Event): void;
    /**
     * Wird nach dem Schließen des Menus aufgerufen und emitted die Output-Property.
     * Setzt den Fokus auf den Default-Trigger (Custom-Trigger => eigene Verantwortung).
     */
    onMenuClosed(): void;
    /**
     * Wird nach dem Öffnen des Menus aufgerufen und emitted die Output-Property.
     */
    onMenuOpened(): void;
    /**
     * Der Menü-Trigger in der Filterkomponente wird im Accordion-Panel eingesetzt.
     * Damit sich das Panel bei der Verwendung des Menüs nicht öffnet und schließt,
     * darf das Event nicht weiter gereicht werden.
     * @param event
     */
    menuTriggerStopPropagation(event: Event): void;
    /**
     * Berechnet anhand der verfügbaren Breite des Containers (CSS-Class: lux-menu-extended) und der maximalen Anzahl an
     * extended MenuItems die Anzahl an möglichen MenuItems, die außerhalb des eigentlichen Menus dargestellt werden können.
     */
    updateExtendedMenuItems(): void;
    /**
     * Berechnet die Breite für jedes Menuitem und speichert diese abhängig davon, ob das Item immer sichtbar sein soll oder nicht
     * in 2 verschiedenen Maps.
     */
    private calculateMenuItemWidths;
    /**
     * Gibt die berechnete Breite des MenuItems zurück.
     * Diese setzt sich aus dem Padding (links und rechts, je 16px), dem Icon (wenn vorhanden, 15px) und der berechneten
     * Textbreite zusammen + 25px Sicherheitspuffer.
     * @param menuItem
     */
    private getMenuItemWidth;
    /**
     * Berechnet mithilfe eines Canvas-Objekts die Breite eines einzelnen Textes
     * @param text
     */
    private getTextWidth;
    hasVisibleMenuItems(): boolean;
    isItemDivider(menuItem: any): menuItem is LuxDividerComponent;
    isItemMenuItem(menuItem: any): menuItem is LuxMenuItemComponent;
    isPanelHeader(menuItem: any): menuItem is LuxMenuPanelHeaderComponent;
    isSectionTitle(menuItem: any): menuItem is LuxMenuSectionTitleComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMenuComponent, "lux-menu", never, { "luxMenuLabel": { "alias": "luxMenuLabel"; "required": false; }; "luxMenuIconName": { "alias": "luxMenuIconName"; "required": false; }; "luxMenuTriggerIconShowRight": { "alias": "luxMenuTriggerIconShowRight"; "required": false; }; "luxMenuItemFixWidth": { "alias": "luxMenuItemFixWidth"; "required": false; }; "luxClassName": { "alias": "luxClassName"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxToggleDisabled": { "alias": "luxToggleDisabled"; "required": false; }; "luxAriaMenuTriggerLabel": { "alias": "luxAriaMenuTriggerLabel"; "required": false; }; "luxShowSections": { "alias": "luxShowSections"; "required": false; "isSignal": true; }; "luxMenuPanelLarge": { "alias": "luxMenuPanelLarge"; "required": false; "isSignal": true; }; "luxDisplayExtended": { "alias": "luxDisplayExtended"; "required": false; }; "luxDisplayMenuLeft": { "alias": "luxDisplayMenuLeft"; "required": false; }; "luxMaximumExtended": { "alias": "luxMaximumExtended"; "required": false; }; }, { "luxMenuClosed": "luxMenuClosed"; "luxMenuOpened": "luxMenuOpened"; }, ["luxMenuTriggerComponent", "luxMenuItemComponents", "menuNotExtendedPanel"], ["lux-menu-trigger"], true, never>;
}

declare class LuxAppHeaderAcActionNavItemCustomComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcActionNavItemCustomComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcActionNavItemCustomComponent, "lux-app-header-ac-action-nav-item-custom", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxAppHeaderAcActionNavItemComponent {
    luxLabel: string;
    luxIconName?: string;
    luxColor: LuxThemePalette;
    luxDisabled: boolean;
    luxTagId?: string;
    luxClicked: EventEmitter<Event>;
    buttonComponent?: LuxButtonComponent;
    customComponent?: LuxAppHeaderAcActionNavItemCustomComponent;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcActionNavItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcActionNavItemComponent, "lux-app-header-ac-action-nav-item", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; }, { "luxClicked": "luxClicked"; }, ["customComponent"], ["lux-app-header-ac-action-nav-item-custom"], true, never>;
}

declare class LuxAppHeaderActionNavItemCustomComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderActionNavItemCustomComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderActionNavItemCustomComponent, "lux-app-header-action-nav-item-custom", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxAppHeaderActionNavItemComponent {
    luxLabel: string;
    luxIconName?: string;
    luxColor: LuxThemePalette;
    luxDisabled: boolean;
    luxTagId?: string;
    luxClicked: EventEmitter<Event>;
    buttonComponent?: LuxButtonComponent;
    customComponent?: LuxAppHeaderActionNavItemCustomComponent;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderActionNavItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderActionNavItemComponent, "lux-app-header-action-nav-item", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; }, { "luxClicked": "luxClicked"; }, ["customComponent"], ["lux-app-header-action-nav-item-custom"], true, never>;
}

declare class LuxTooltipDirective extends MatTooltip implements OnChanges, AfterViewInit {
    luxTooltip: string;
    luxTooltipHideDelay: number;
    luxTooltipShowDelay: number;
    luxTooltipPosition: TooltipPosition;
    luxTooltipDisabled: boolean;
    luxButton: LuxButtonComponent | null;
    luxLink: LuxLinkComponent | null;
    luxLinkPlain: LuxLinkPlainComponent | null;
    luxActionNavAc: LuxAppHeaderAcActionNavItemComponent | null;
    luxActionNav: LuxAppHeaderActionNavItemComponent | null;
    luxMenu: LuxMenuComponent | null;
    _handleLongPress(): void;
    _handleEscape(): void;
    show(delay?: number): void;
    hide(delay?: number): void;
    ngAfterViewInit(): void;
    ngOnChanges(_simpleChanges: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxTooltipDirective, "[luxTooltip]", ["luxTooltip"], { "luxTooltip": { "alias": "luxTooltip"; "required": false; }; "luxTooltipHideDelay": { "alias": "luxTooltipHideDelay"; "required": false; }; "luxTooltipShowDelay": { "alias": "luxTooltipShowDelay"; "required": false; }; "luxTooltipPosition": { "alias": "luxTooltipPosition"; "required": false; }; "luxTooltipDisabled": { "alias": "luxTooltipDisabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxButtonComponent extends LuxActionComponentBaseClass implements OnInit, OnDestroy {
    elementRef: ElementRef<any>;
    componentsConfigService: LuxComponentsConfigService;
    tooltipDirective?: LuxTooltipDirective;
    private configSubscription;
    private clickSubject;
    private clickSubscription;
    private auxClickSubject;
    private auxClickSubscription;
    private clickNotAllowedSubject;
    private clickNotAllowedSubscription;
    luxType: 'button' | 'reset' | 'submit';
    luxThrottleTime: number;
    luxButtonBadge?: string;
    luxButtonBadgeColor?: LuxThemePalette;
    luxSpinnerMode: LuxProgressModeType;
    luxSpinnerValue: number;
    luxLoading: boolean;
    luxDisabledAria: boolean;
    luxIconButton: boolean;
    luxAuxClicked: EventEmitter<Event>;
    luxClickNotAllowed: EventEmitter<Event>;
    labelUppercase: boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    clicked(event: MouseEvent): void;
    auxClicked(event: MouseEvent): void;
    private detectParent;
    private shouldHandleNotAllowedClick;
    private emitClickNotAllowed;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxButtonComponent, "lux-button", never, { "luxType": { "alias": "luxType"; "required": false; }; "luxThrottleTime": { "alias": "luxThrottleTime"; "required": false; }; "luxButtonBadge": { "alias": "luxButtonBadge"; "required": false; }; "luxButtonBadgeColor": { "alias": "luxButtonBadgeColor"; "required": false; }; "luxSpinnerMode": { "alias": "luxSpinnerMode"; "required": false; }; "luxSpinnerValue": { "alias": "luxSpinnerValue"; "required": false; }; "luxLoading": { "alias": "luxLoading"; "required": false; }; "luxDisabledAria": { "alias": "luxDisabledAria"; "required": false; }; "luxIconButton": { "alias": "luxIconButton"; "required": false; }; }, { "luxAuxClicked": "luxAuxClicked"; "luxClickNotAllowed": "luxClickNotAllowed"; }, never, never, true, never>;
}

declare abstract class LuxAriaBase<T> implements AfterViewInit {
    protected init: boolean;
    protected elementRef: ElementRef<any>;
    protected renderer: Renderer2;
    protected abstract ariaTagName: string;
    ngAfterViewInit(): void;
    protected renderAria(): void;
    abstract getSelector(): string | undefined;
    abstract getValue(): T | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaBase<any>, never, never, {}, {}, never, never, true, never>;
}

declare class LuxAriaDescribedbyDirective extends LuxAriaBase<string> {
    protected ariaTagName: string;
    _luxAriaDescribedby?: string;
    luxAriaDescribedbySelector?: string;
    get luxAriaDescribedby(): string | undefined;
    set luxAriaDescribedby(describedby: string | undefined);
    constructor();
    getSelector(): string | undefined;
    getValue(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaDescribedbyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaDescribedbyDirective, "[luxAriaDescribedby]", never, { "luxAriaDescribedbySelector": { "alias": "luxAriaDescribedbySelector"; "required": false; }; "luxAriaDescribedby": { "alias": "luxAriaDescribedby"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaExpandedDirective extends LuxAriaBase<boolean> {
    protected ariaTagName: string;
    _luxAriaExpanded?: boolean;
    luxAriaExpandedSelector?: string;
    get luxAriaExpanded(): boolean | undefined;
    set luxAriaExpanded(expanded: boolean | undefined);
    constructor();
    getSelector(): string | undefined;
    getValue(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaExpandedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaExpandedDirective, "[luxAriaExpanded]", never, { "luxAriaExpandedSelector": { "alias": "luxAriaExpandedSelector"; "required": false; }; "luxAriaExpanded": { "alias": "luxAriaExpanded"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaHaspopupDirective extends LuxAriaBase<boolean> {
    protected ariaTagName: string;
    _luxAriaHasPopup?: boolean | undefined;
    luxAriaHasPopupSelector?: string;
    get luxAriaHasPopup(): boolean | undefined;
    set luxAriaHasPopup(hasPopup: boolean | undefined);
    constructor();
    getSelector(): string | undefined;
    getValue(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaHaspopupDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaHaspopupDirective, "[luxAriaHasPopup]", never, { "luxAriaHasPopupSelector": { "alias": "luxAriaHasPopupSelector"; "required": false; }; "luxAriaHasPopup": { "alias": "luxAriaHasPopup"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaHiddenDirective extends LuxAriaBase<boolean> {
    protected ariaTagName: string;
    _luxAriaHidden?: boolean;
    luxAriaHiddenSelector?: string;
    get luxAriaHidden(): boolean | undefined;
    set luxAriaHidden(hidden: boolean | undefined);
    getSelector(): string | undefined;
    getValue(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaHiddenDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaHiddenDirective, "[luxAriaHidden]", never, { "luxAriaHiddenSelector": { "alias": "luxAriaHiddenSelector"; "required": false; }; "luxAriaHidden": { "alias": "luxAriaHidden"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaInvalidDirective extends LuxAriaBase<string> {
    protected ariaTagName: string;
    _luxAriaInvalid?: string;
    luxAriaInvalidSelector?: string;
    get luxAriaInvalid(): string | undefined;
    set luxAriaInvalid(invalid: string | undefined);
    getSelector(): string | undefined;
    getValue(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaInvalidDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaInvalidDirective, "[luxAriaInvalid]", never, { "luxAriaInvalidSelector": { "alias": "luxAriaInvalidSelector"; "required": false; }; "luxAriaInvalid": { "alias": "luxAriaInvalid"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaLabelDirective extends LuxAriaBase<string> {
    protected ariaTagName: string;
    _luxAriaLabel?: string;
    luxAriaLabelSelector?: string;
    get luxAriaLabel(): string | undefined;
    set luxAriaLabel(label: string | undefined);
    constructor();
    getSelector(): string | undefined;
    getValue(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaLabelDirective, "[luxAriaLabel]", never, { "luxAriaLabelSelector": { "alias": "luxAriaLabelSelector"; "required": false; }; "luxAriaLabel": { "alias": "luxAriaLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaLabelledbyDirective extends LuxAriaBase<string> {
    protected ariaTagName: string;
    _luxAriaLabelledby?: string;
    luxAriaLabelledbySelector?: string;
    get luxAriaLabelledby(): string | undefined;
    set luxAriaLabelledby(labelledby: string | undefined);
    constructor();
    getSelector(): string | undefined;
    getValue(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaLabelledbyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaLabelledbyDirective, "[luxAriaLabelledby]", never, { "luxAriaLabelledbySelector": { "alias": "luxAriaLabelledbySelector"; "required": false; }; "luxAriaLabelledby": { "alias": "luxAriaLabelledby"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaRequiredDirective extends LuxAriaBase<boolean> {
    protected ariaTagName: string;
    _luxAriaRequired?: boolean;
    luxAriaRequiredSelector?: string;
    get luxAriaRequired(): boolean | undefined;
    set luxAriaRequired(required: boolean | undefined);
    getSelector(): string | undefined;
    getValue(): boolean | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaRequiredDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaRequiredDirective, "[luxAriaRequired]", never, { "luxAriaRequiredSelector": { "alias": "luxAriaRequiredSelector"; "required": false; }; "luxAriaRequired": { "alias": "luxAriaRequired"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAriaRoleDirective extends LuxAriaBase<string> {
    protected ariaTagName: string;
    _luxAriaRole?: string;
    luxAriaRoleSelector?: string;
    get luxAriaRole(): string | undefined;
    set luxAriaRole(role: string | undefined);
    getSelector(): string | undefined;
    getValue(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAriaRoleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAriaRoleDirective, "[luxAriaRole]", never, { "luxAriaRoleSelector": { "alias": "luxAriaRoleSelector"; "required": false; }; "luxAriaRole": { "alias": "luxAriaRole"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAutofocusDirective implements AfterViewInit {
    private elementRef;
    luxAutofocusSelector?: string;
    luxAutofocusComponent?: any;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAutofocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxAutofocusDirective, "[luxAutofocus]", never, { "luxAutofocusSelector": { "alias": "luxAutofocusSelector"; "required": false; }; "luxAutofocusComponent": { "alias": "luxAutofocusComponent"; "required": false; }; }, {}, never, never, true, never>;
}

declare type LuxBadgeNotificationColor = 'primary' | 'warn' | 'accent' | string;
declare type LuxBadgeNotificationSize = 'small' | 'medium' | 'large';
declare type LuxBadgeNotificationPosition = 'above after' | 'above before' | 'below before' | 'below after';
declare class LuxBadgeNotificationDirective extends MatBadge implements OnChanges {
    private luxElementRef;
    static readonly WHITE_SPACE = "\u200B";
    luxBadgeNotification: string;
    luxBadgeColor: LuxBadgeNotificationColor;
    luxBadgeSize: LuxBadgeNotificationSize;
    luxBadgePosition: LuxBadgeNotificationPosition;
    luxBadgeDisabled: boolean;
    luxBadgeHidden: boolean;
    luxBadgeOverlap: boolean;
    luxBadgeNoBorder: boolean;
    luxBadgeCap: number;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    updateContent(value: any): void;
    isHidden(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxBadgeNotificationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxBadgeNotificationDirective, "[luxBadgeNotification], [lux-badge-notification]", never, { "luxBadgeNotification": { "alias": "luxBadgeNotification"; "required": false; }; "luxBadgeColor": { "alias": "luxBadgeColor"; "required": false; }; "luxBadgeSize": { "alias": "luxBadgeSize"; "required": false; }; "luxBadgePosition": { "alias": "luxBadgePosition"; "required": false; }; "luxBadgeDisabled": { "alias": "luxBadgeDisabled"; "required": false; }; "luxBadgeHidden": { "alias": "luxBadgeHidden"; "required": false; }; "luxBadgeOverlap": { "alias": "luxBadgeOverlap"; "required": false; }; "luxBadgeNoBorder": { "alias": "luxBadgeNoBorder"; "required": false; }; "luxBadgeCap": { "alias": "luxBadgeCap"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxInfiniteScrollDirective implements OnInit, AfterViewInit, OnDestroy {
    private elementRef;
    static readonly SCROLL_DEBOUNCE_TIME: number;
    private scrollSubscription;
    private scroll$;
    private lastPosition;
    luxScrollPercent: number;
    luxImmediateCallback: boolean;
    luxIsLoading: boolean;
    luxScrolled: EventEmitter<void>;
    /**
     * Constructor
     * @param elementRef Ziel-Element dieser Direktive
     */
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Prüft, ob ein Scroll-Event auf dem Zielelement stattgefunden hat.
     * Wenn ja, wird das Subject scroll$ angestoßen.
     * @param event
     */
    onScroll(event: any): void;
    /**
     * Holt die aktuelle Position im Scroll-Bereich und führt
     * einen Event-Emit durch, wenn die Bedingungen erfüllt sind.
     */
    private performScrollCheck;
    /**
     * Prüft, ob der User gerade nach unten scrollt.
     * Vergleicht dabei die scrollTop Position des Users mit der des Elements.
     * @param curPos
     */
    private isUserScrollingDown;
    /**
     * Prüft, ob der Scrollbereich überschritten wurde.
     * @param position
     * @returns boolean
     */
    private isScrollExpectedPercent;
    /**
     * Prüft, ob das Zielelement eine Scrollbar gesetzt hat.
     */
    private hasScrollbar;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxInfiniteScrollDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxInfiniteScrollDirective, "[luxInfiniteScroll]", never, { "luxScrollPercent": { "alias": "luxScrollPercent"; "required": false; }; "luxImmediateCallback": { "alias": "luxImmediateCallback"; "required": false; }; "luxIsLoading": { "alias": "luxIsLoading"; "required": false; }; }, { "luxScrolled": "luxScrolled"; }, never, never, true, never>;
}

/**
 * Enthält eine einzelne Scroll-Position
 * scrollHeight = Höhe des Scrollbars
 * scrollTop = Entfernung nach oben
 * clientHeight = Höhe des Mont
 */
interface LuxScrollPosition {
    scrollHeight: number;
    scrollTop: number;
    clientHeight: number;
}

declare class LuxRippleDirective extends MatRipple implements OnInit, OnDestroy {
    private configService;
    private luxElementRef;
    private luxNgZone;
    private luxPlatform;
    private luxGlobalOptions;
    private luxAnimationMode;
    configSubscription: Subscription;
    _luxRippleColor: string;
    _luxRippleUnbounded: boolean;
    _luxRippleCentered: boolean;
    _luxRippleDisabled: boolean;
    _luxRippleRadius: number;
    _luxRippleEnterDuration: number;
    _luxRippleExitDuration: number;
    get luxRippleColor(): string;
    set luxRippleColor(value: string);
    get luxRippleUnbounded(): boolean;
    set luxRippleUnbounded(value: boolean);
    get luxRippleCentered(): boolean;
    set luxRippleCentered(value: boolean);
    get luxRippleRadius(): number;
    set luxRippleRadius(value: number);
    get luxRippleDisabled(): boolean;
    set luxRippleDisabled(value: boolean);
    get luxRippleEnterDuration(): number;
    set luxRippleEnterDuration(value: number);
    get luxRippleExitDuration(): number;
    set luxRippleExitDuration(value: number);
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxRippleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxRippleDirective, "[luxRipple], [lux-ripple]", never, { "luxRippleColor": { "alias": "luxRippleColor"; "required": false; }; "luxRippleUnbounded": { "alias": "luxRippleUnbounded"; "required": false; }; "luxRippleCentered": { "alias": "luxRippleCentered"; "required": false; }; "luxRippleRadius": { "alias": "luxRippleRadius"; "required": false; }; "luxRippleDisabled": { "alias": "luxRippleDisabled"; "required": false; }; "luxRippleEnterDuration": { "alias": "luxRippleEnterDuration"; "required": false; }; "luxRippleExitDuration": { "alias": "luxRippleExitDuration"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxTabIndexDirective implements AfterViewInit, OnChanges, OnDestroy {
    private elementRef;
    private renderer;
    private changesSubscription?;
    private changes$;
    luxTabIndex: string;
    luxApplyToParent: boolean;
    luxApplyToChildren: boolean;
    luxPotentialChildren: string[];
    ngOnChanges(simpleChanges: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Eigener Listener für Änderungen, der erst nach dem AfterViewInit-Lifecycle greift.
     * Sicherheitshalber, um evtl. noch unaufgelösten Elementen zu entgehen.
     * @param simpleChanges
     */
    private onChanges;
    /**
     * Aktualisiert den Tabindex für
     *  - das Zielelement, wenn luxApplyToParent === true (default = false) ist
     *  - potentielle Kindelemente, wenn luxApplyToChildren === true (default) ist
     */
    private updateElementsWithTabIndex;
    private setTabIndexByQuery;
    private setTabIndexForElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTabIndexDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxTabIndexDirective, "[luxTabIndex]", never, { "luxTabIndex": { "alias": "luxTabIndex"; "required": false; }; "luxApplyToParent": { "alias": "luxApplyToParent"; "required": false; }; "luxApplyToChildren": { "alias": "luxApplyToChildren"; "required": false; }; "luxPotentialChildren": { "alias": "luxPotentialChildren"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxCustomTagIdDirective implements AfterViewInit, OnDestroy {
    protected elementRef: ElementRef<any>;
    protected renderer: Renderer2;
    componentsConfigService: LuxComponentsConfigService;
    generateLuxTagIds: boolean;
    configSubscription: Subscription;
    luxCustomTagId?: string;
    luxCustomTagIdSelector?: string;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCustomTagIdDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxCustomTagIdDirective, "[luxCustomTagId]", never, { "luxCustomTagId": { "alias": "luxCustomTagId"; "required": false; }; "luxCustomTagIdSelector": { "alias": "luxCustomTagIdSelector"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxTagIdDirective implements AfterViewInit, OnDestroy {
    private elementRef;
    private renderer;
    componentsConfigService: LuxComponentsConfigService;
    static readonly luxTagIdAttrName: string;
    static readonly sepParent: string;
    static readonly sepComponent: string;
    private configSubscription;
    luxTagId?: string;
    luxTagIdStartElement: Element | null;
    luxTagIdTargetSelf: boolean;
    generateLuxTagIds: boolean;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private getParentPath;
    private getLuxTagIdParent;
    private mergeTagIds;
    private getLuxTagId;
    private getAttributeValue;
    private findLuxComponent;
    private getNodeName;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTagIdDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxTagIdDirective, "[luxTagIdHandler]", never, { "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxTagIdStartElement": { "alias": "luxTagIdStartElement"; "required": false; }; "luxTagIdTargetSelf": { "alias": "luxTagIdTargetSelf"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxBadgeComponent {
    readonly ICON_SIZE: string;
    readonly DEFAULT_BADGE_COLOR = "gray";
    luxUppercase: boolean;
    luxIconName: string;
    luxColor: LuxBadgeColor;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxBadgeComponent, "lux-badge", never, { "luxUppercase": { "alias": "luxUppercase"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; }, {}, never, ["lux-label"], true, never>;
}

declare class LuxLabelComponent implements OnInit {
    luxId?: string;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLabelComponent, "lux-label", never, { "luxId": { "alias": "luxId"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Interface, welches die Struktur einer einzelnen Message für die LuxMessageBox definiert.
 */

interface ILuxMessage {
    text: string;
    iconName?: string;
    color?: LuxMessageBoxColor;
}

/**
 * Event-Interface, welches beim Klick auf den next- und previous-Button über einen EventEmitter
 * ausgegeben wird.
 */
interface ILuxMessageChangeEvent {
    currentPage: {
        index: number;
        messages: ILuxMessage[];
    };
    previousPage: {
        index: number;
        messages: ILuxMessage[];
    };
}
/**
 * Event-Interface, welches vom LuxMessageChangeEvent und beim Klick auf den close-Button über einen
 * Event-Emitter ausgegeben wird.
 */
interface ILuxMessageCloseEvent {
    index: number;
    message: ILuxMessage;
}

declare class LuxMessageComponent {
    private _luxMessage?;
    luxMessageClosed: EventEmitter<ILuxMessage>;
    set luxMessage(message: ILuxMessage | undefined);
    get luxMessage(): ILuxMessage | undefined;
    constructor();
    /**
     * Setzt die Messages auf ein leeres Array, um so die MessageBox auszublenden.
     */
    close(): void;
    /**
     * Aktualisiert die Farbe dieser Box passend zur Farbe der Nachricht.
     */
    private updateColor;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMessageComponent, "lux-message", never, { "luxMessage": { "alias": "luxMessage"; "required": false; }; }, { "luxMessageClosed": "luxMessageClosed"; }, never, never, true, never>;
}

declare class LuxMessageBoxComponent {
    private liveAnnouncer;
    private tService;
    private _luxMessages;
    private _luxMaximumDisplayed;
    private _luxIndex;
    displayedMessages: ILuxMessage[];
    boxShadow: boolean;
    messageBoxElRef?: ElementRef;
    luxMessageChanged: EventEmitter<ILuxMessageChangeEvent>;
    luxMessageClosed: EventEmitter<ILuxMessageCloseEvent>;
    luxMessageBoxClosed: EventEmitter<void>;
    luxMessagesChange: EventEmitter<ILuxMessage[]>;
    luxGrabFocus: boolean;
    set luxIndex(index: number);
    get luxIndex(): number;
    set luxMaximumDisplayed(max: number);
    get luxMaximumDisplayed(): number;
    set luxMessages(messages: ILuxMessage[]);
    get luxMessages(): ILuxMessage[];
    /**
     * Wird aufgerufen, wenn der Close-Button für eine MessageBox aufgerufen wurde.
     *
     * Gibt eine Event-Payload mit der betroffenen Nachricht mit Index weiter.
     * @param closedMessage
     */
    messageClosed(closedMessage: ILuxMessage): void;
    /**
     * Aktualisiert die angezeigten Nachrichten und den Paginator,
     * gibt außerdem das Change-Event mit den angezeigten/vorherigen Nachrichten.
     * @param pageEvent
     */
    pageChanged(pageEvent: PageEvent): void;
    /**
     * Aktualisiert die aktuell angezeigten Nachrichten anhand des Index.
     * @param pageIndex
     */
    updateDisplayedMessages(pageIndex: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMessageBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMessageBoxComponent, "lux-message-box", never, { "luxGrabFocus": { "alias": "luxGrabFocus"; "required": false; }; "luxIndex": { "alias": "luxIndex"; "required": false; }; "luxMaximumDisplayed": { "alias": "luxMaximumDisplayed"; "required": false; }; "luxMessages": { "alias": "luxMessages"; "required": false; }; }, { "luxMessageChanged": "luxMessageChanged"; "luxMessageClosed": "luxMessageClosed"; "luxMessageBoxClosed": "luxMessageBoxClosed"; "luxMessagesChange": "luxMessagesChange"; }, never, never, true, never>;
}

/**
 * Interface für die Speicherung der Sichtbarkeit von Tabellenspalten.
 *
 * Der Key ist dabei ein eindeutiger Bezeichner für die Tabelle (z.B. "userTable").
 * Der Wert ist ein Array von Spalten-Definitionsnamen (columnDef), die ausgeblendet sind.
 */
interface ILuxTableColumnVisibilityStore {
    load(key: string): string[];
    save(key: string, hidden: string[]): void;
}
declare class LuxTableLocalColumnVisibilityStore implements ILuxTableColumnVisibilityStore {
    private consentService;
    private storageService;
    load(key: string): string[];
    save(key: string, hidden: string[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTableLocalColumnVisibilityStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxTableLocalColumnVisibilityStore>;
}

interface ICustomCSSConfig {
    class: string;
    check: (element: any) => boolean;
}

/**
 * Diese Ableitung berücksichtigt bei der Sortierung Sonderzeichen (z.B. öäüßé,...)
 * und ignoriert die Groß- und Kleinschreibung.
 */
declare class LuxTableDataSource<T> extends MatTableDataSource<T> {
    totalElements: number;
    selectedEntries: Set<any>;
    /**
     * Diese Methode liefert eine sortierte Kopie des Datenarrays zurück.
     * Die Sortierung berücksichtigt ist nicht Case-Sensitive und berücksichtigt
     * Sonderzeichen (z.B. öäüßé,...)
     * @param data
     */
    _orderData(data: T[]): T[];
    /**
     * Override update paginator method
     * to ensure total unfiltered element count is consistent with the http result
     * @param filteredDataLength
     */
    _updatePaginator(filteredDataLength: number): void;
}

interface ILuxTableHttpDaoStructure {
    items: any[];
    totalCount: number;
}

interface ILuxTableHttpDao {
    loadData(conf: {
        page?: number;
        pageSize?: number;
        filter?: string;
        sort?: string;
        order?: string;
    }): Observable<ILuxTableHttpDaoStructure>;
}

declare class LuxTableColumnContentComponent<T = any> implements AfterContentInit {
    tempRef?: TemplateRef<T>;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTableColumnContentComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTableColumnContentComponent<any>, "lux-table-column-content", never, {}, {}, ["tempRef"], never, true, never>;
}

declare class LuxTableColumnFooterComponent<T = any> implements AfterContentInit {
    tempRef: TemplateRef<T>;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTableColumnFooterComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTableColumnFooterComponent<any>, "lux-table-column-footer", never, {}, {}, ["tempRef"], never, true, never>;
}

declare class LuxTableColumnHeaderComponent<T = any> implements AfterContentInit {
    tempRef: TemplateRef<T>;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTableColumnHeaderComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTableColumnHeaderComponent<any>, "lux-table-column-header", never, {}, {}, ["tempRef"], never, true, never>;
}

declare class LuxTableColumnComponent implements OnInit, OnChanges {
    change$: Subject<void>;
    luxConfigLabel?: string;
    luxColumnDef: string;
    luxSortable: boolean;
    luxSticky: boolean;
    luxResponsiveBehaviour: string;
    luxResponsiveAt: string | string[] | null;
    header?: LuxTableColumnHeaderComponent;
    content?: LuxTableColumnContentComponent;
    footer?: LuxTableColumnFooterComponent;
    constructor();
    ngOnInit(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTableColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTableColumnComponent, "lux-table-column", never, { "luxConfigLabel": { "alias": "luxConfigLabel"; "required": false; }; "luxColumnDef": { "alias": "luxColumnDef"; "required": false; }; "luxSortable": { "alias": "luxSortable"; "required": false; }; "luxSticky": { "alias": "luxSticky"; "required": false; }; "luxResponsiveBehaviour": { "alias": "luxResponsiveBehaviour"; "required": false; }; "luxResponsiveAt": { "alias": "luxResponsiveAt"; "required": false; }; }, {}, ["header", "content", "footer"], ["lux-table-column-header", "lux-table-column-content", "lux-table-column-footer"], true, never>;
}

declare const noop: () => any;
declare class LuxConsoleService implements OnDestroy {
    static config: LuxComponentsConfigParameters;
    configSubscription: Subscription;
    constructor();
    get log(): (...args: any[]) => unknown;
    get info(): (...args: any[]) => unknown;
    get warn(): (...args: any[]) => unknown;
    get error(): (...args: any[]) => unknown;
    get group(): (...args: any[]) => unknown;
    get groupEnd(): (...args: any[]) => unknown;
    static LOG(...args: any[]): void;
    static WARN(...args: any[]): void;
    static ERROR(...args: any[]): void;
    private static logDate;
    private static getLogValue;
    private static isDebugMode;
    private static checkTime;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxConsoleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxConsoleService>;
}

declare const luxFormControlSelektor = "lux-form-control-wrapper";
declare class LuxFormControlWrapperComponent {
    private cdr;
    focused: boolean;
    _luxNoTopLabel: boolean;
    _luxNoLabels: boolean;
    _luxNoBottomLabel: boolean;
    /**
     * Die zugrunde liegende FormComponent
     */
    luxFormComponent: LuxFormComponentBase;
    luxFormComponentElementRef: ElementRef;
    luxIgnoreDefaultLabel: boolean;
    luxCounterLabel: string;
    luxHideCounterLabel: boolean;
    luxLabelLongFormat: boolean;
    luxNoInputRow: boolean;
    luxDisplayClearErrorButton: boolean;
    /**
     * Dient dazu, bei einer Component den Label-Container auszublenden.
     * @param noLabel
     */
    set luxNoTopLabel(noLabel: boolean);
    get luxNoTopLabel(): boolean;
    /**
     * Dient dazu, bei einer Component den Label-Container und den Misc-Container auszublenden.
     * @param noLabel
     */
    set luxNoLabels(noLabel: boolean);
    get luxNoLabels(): boolean;
    /**
     * Dient dazu, bei einer Component den Misc-Container auszublenden.
     * @param noLabel
     */
    set luxNoBottomLabel(noLabel: boolean);
    get luxNoBottomLabel(): boolean;
    /**
     * Gibt wieder, ob der Fehler für diese FormComponent dargestellt werden soll.
     */
    shouldDisplayError(): boolean | "" | undefined;
    shouldDisplayMisc(): boolean;
    shouldDisplayLabelByProperty(): string | false;
    shouldDisplayHintByProperty(): boolean | undefined;
    /**
     * Aktiviert den Fokus dieser Component.
     */
    focusin(): void;
    /**
     * Deaktiviert den Fokus dieser Component.
     */
    focusout(): void;
    onCloseErrorMessage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormControlWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFormControlWrapperComponent, "lux-form-control-wrapper", never, { "luxFormComponent": { "alias": "luxFormComponent"; "required": false; }; "luxFormComponentElementRef": { "alias": "luxFormComponentElementRef"; "required": false; }; "luxIgnoreDefaultLabel": { "alias": "luxIgnoreDefaultLabel"; "required": false; }; "luxCounterLabel": { "alias": "luxCounterLabel"; "required": false; }; "luxHideCounterLabel": { "alias": "luxHideCounterLabel"; "required": false; }; "luxLabelLongFormat": { "alias": "luxLabelLongFormat"; "required": false; }; "luxNoInputRow": { "alias": "luxNoInputRow"; "required": false; }; "luxDisplayClearErrorButton": { "alias": "luxDisplayClearErrorButton"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class LuxFormHintComponent implements AfterViewInit {
    templateRef: TemplateRef<any>;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormHintComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFormHintComponent, "lux-form-hint", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxFormLabelComponent implements AfterViewInit {
    templateRef: TemplateRef<any>;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFormLabelComponent, "lux-form-label", never, {}, {}, never, ["*"], true, never>;
}

declare type LuxValidationErrors = ValidationErrors;
declare type ValidatorFnType = ValidatorFn | ValidatorFn[] | null | undefined;
declare type LuxErrorCallbackFnType = (value: any, errors: LuxValidationErrors) => string | undefined;
declare abstract class LuxFormComponentBase<T = any> implements OnInit, DoCheck, OnDestroy {
    protected static readonly DEFAULT_CTRL_NAME: string;
    protected _formValueChangeSub?: Subscription;
    protected _formStatusChangeSub?: Subscription;
    protected _configSubscription?: Subscription;
    private hasHadRequiredValidator;
    protected latestErrors: any;
    protected _initialValue?: any;
    protected _initialDisabled?: boolean;
    protected _luxDisabled: boolean;
    protected _luxReadonly: boolean;
    protected _luxRequired: boolean;
    protected _luxControlValidators?: ValidatorFnType;
    errorMessage: string | undefined;
    protected controlContainer: ControlContainer | null;
    protected cdr: ChangeDetectorRef;
    protected logger: LuxConsoleService;
    protected configService: LuxComponentsConfigService;
    protected tService: TranslocoService;
    inForm: boolean;
    formGroup: FormGroup;
    formControl: FormControl<T>;
    uid: string;
    formLabelComponent?: LuxFormLabelComponent;
    formHintComponent?: LuxFormHintComponent;
    formControlWrapperComponent?: LuxFormControlWrapperComponent;
    formControlWrapperComponentRef?: ElementRef;
    cssReadonly: boolean;
    luxFocusIn: EventEmitter<FocusEvent>;
    luxFocusOut: EventEmitter<FocusEvent>;
    luxDisabledChange: EventEmitter<boolean>;
    luxId: string;
    luxHint: string;
    luxHintShowOnlyOnFocus: boolean;
    luxLabel: string;
    luxLabelLongFormat: boolean;
    luxControlBinding?: string;
    luxErrorMessage?: string;
    luxErrorCallback: LuxErrorCallbackFnType;
    luxDense: boolean;
    get luxFormControl(): FormControl<T>;
    set luxFormControl(formControl: FormControl<T>);
    get luxFormGroup(): FormGroup;
    set luxFormGroup(formGroup: FormGroup);
    get luxControlValidators(): ValidatorFnType;
    set luxControlValidators(validators: ValidatorFnType);
    get luxDisabled(): boolean;
    set luxDisabled(disabled: boolean);
    get luxReadonly(): boolean;
    set luxReadonly(readonly: boolean);
    get luxRequired(): boolean;
    set luxRequired(required: boolean);
    ngOnInit(): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    /**
     * Versucht eine Fehlermeldung für diese Komponente auszulesen und gibt diese zurück.
     * Wenn das Element nicht den "touched"-Zustand besitzt, wird keine Fehlermeldung zurückgegeben.
     */
    protected fetchErrorMessage(): string | undefined;
    /**
     * Überträgt den Input-Wert aus disabled auf das FormControl.
     */
    protected handleFormDisabledState(): void;
    /**
     * Method-Stub der von ableitenden Klassen genutzt werden kann, um
     * weitergreifende Fehlermeldungen anzugeben.
     * @param value
     * @param errors
     */
    protected errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    /**
     * Standard-Getter Funktion für den aktuellen Wert in dieser FormComponent.
     */
    protected getValue(): T;
    /**
     * Standard-Setter Funktion für den aktuellen Wert in dieser FormComponent.
     * @param value
     */
    protected setValue(value: T): void;
    /**
     * Wird nach der Aktualisierung des Wertes aufgerufen.
     * Hier kann z.B. valueChange.emit() ausgeführt werden.
     * @param formValue
     */
    protected notifyFormValueChanged(formValue: any): void;
    /**
     * Wird nach der Aktualisierung des Status aufgerufen.
     * @param formStatus
     */
    protected notifyFormStatusChanged(formStatus: any): void;
    /**
     * Prüft, ob das übergebene Control einen required-Validator besitzt.
     * @param abstractControl
     */
    protected hasRequiredValidator(abstractControl: AbstractControl): boolean;
    /**
     * Initialisiert die FormGroup und das FormControl abhängig davon, ob es sich um eine ReactiveForm-Component
     * handelt.
     */
    protected initFormControl(): void;
    /**
     * Initialisiert das Handling von Wertaktualisierungen.
     * Setzt den (optional vorhanden) Initial-Wert und folgende Änderungen über das FormControl.
     */
    protected initFormValueSubscription(): void;
    /**
     * Initialisiert das Handling von Statusaktualisierungen.
     */
    protected initFormStateSubscription(): void;
    /**
     * Diese Funktion prüft ob luxRequired auf true gesetzt wurde und die übergebenen validators bereits den
     * required-Validator besitzen.
     * Für den Fall das luxRequired auf false gesetzt worden ist, wird der Validator entfernt.
     *
     * Hinweis: LuxFormCheckableBase überschreibt diese Funktion, um statt required requiredTrue zu setzen.
     * @param validators
     */
    protected checkValidatorsContainRequired(validators: ValidatorFnType): ValidatorFnType;
    /**
     * Versucht die Validatoren für diese Komponente zu setzen.
     * Ist nur erfolgreich, wenn es sich hierbei nicht um eine ReactiveForm-Komponente handelt.
     * @param validators
     * @param checkRequiredValidator
     */
    protected updateValidators(validators: ValidatorFnType, checkRequiredValidator: boolean): void;
    private updateValidatorsInForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormComponentBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFormComponentBase<any>, never, never, { "luxId": { "alias": "luxId"; "required": false; }; "luxHint": { "alias": "luxHint"; "required": false; }; "luxHintShowOnlyOnFocus": { "alias": "luxHintShowOnlyOnFocus"; "required": false; }; "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxLabelLongFormat": { "alias": "luxLabelLongFormat"; "required": false; }; "luxControlBinding": { "alias": "luxControlBinding"; "required": false; }; "luxErrorMessage": { "alias": "luxErrorMessage"; "required": false; }; "luxErrorCallback": { "alias": "luxErrorCallback"; "required": false; }; "luxDense": { "alias": "luxDense"; "required": false; }; "luxFormControl": { "alias": "luxFormControl"; "required": false; }; "luxFormGroup": { "alias": "luxFormGroup"; "required": false; }; "luxControlValidators": { "alias": "luxControlValidators"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxReadonly": { "alias": "luxReadonly"; "required": false; }; "luxRequired": { "alias": "luxRequired"; "required": false; }; }, { "luxFocusIn": "luxFocusIn"; "luxFocusOut": "luxFocusOut"; "luxDisabledChange": "luxDisabledChange"; }, ["formLabelComponent", "formHintComponent"], never, true, never>;
}

/**
 * Basis-Klasse für FormComponents, die einen ähnlichen Grundaufbau für das Eintippen von String-Daten haben
 * (Input und Textarea z.B.).
 */
declare abstract class LuxFormInputBaseClass<T = any> extends LuxFormComponentBase<T> {
    luxValueChange: EventEmitter<T>;
    luxBlur: EventEmitter<FocusEvent>;
    luxFocus: EventEmitter<FocusEvent>;
    luxPlaceholder: string;
    luxTagId?: string;
    luxName?: string;
    luxAutocomplete: string;
    get luxValue(): T;
    set luxValue(value: T);
    notifyFormValueChanged(formValue: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormInputBaseClass<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFormInputBaseClass<any>, never, never, { "luxPlaceholder": { "alias": "luxPlaceholder"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxName": { "alias": "luxName"; "required": false; }; "luxAutocomplete": { "alias": "luxAutocomplete"; "required": false; }; "luxValue": { "alias": "luxValue"; "required": false; }; }, { "luxValueChange": "luxValueChange"; "luxBlur": "luxBlur"; "luxFocus": "luxFocus"; }, never, never, true, never>;
}

declare class LuxInputAcPrefixComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxInputAcPrefixComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxInputAcPrefixComponent, "lux-input-ac-prefix", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxInputAcSuffixComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxInputAcSuffixComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxInputAcSuffixComponent, "lux-input-ac-suffix", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxInputAcComponent<T = string> extends LuxFormInputBaseClass<T> implements OnInit {
    private readonly symbolRegExp;
    private liveAnnouncer;
    luxType: string;
    luxNumberAlignLeft: boolean;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    luxHideCounterLabel: boolean;
    set luxMaxLength(maxLength: number);
    get luxMaxLength(): number;
    inputPrefix?: LuxInputAcPrefixComponent;
    inputSuffix?: LuxInputAcSuffixComponent;
    inputElement: ElementRef;
    counterLabel: string;
    focused: boolean;
    _luxMaxLength: number;
    ngOnInit(): void;
    /**
     * Wird bei jedem Tastendruck auf dem Inputfeld aufgerufen.
     * @param keyboardEvent
     */
    onKeyDown(keyboardEvent: KeyboardEvent): void;
    onFocus(e: FocusEvent): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    notifyFormValueChanged(formValue: any): void;
    private updateCounterLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxInputAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxInputAcComponent<any>, "lux-input-ac", never, { "luxType": { "alias": "luxType"; "required": false; }; "luxNumberAlignLeft": { "alias": "luxNumberAlignLeft"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; "luxHideCounterLabel": { "alias": "luxHideCounterLabel"; "required": false; }; "luxMaxLength": { "alias": "luxMaxLength"; "required": false; }; }, {}, ["inputPrefix", "inputSuffix"], ["lux-input-ac-prefix", "lux-input-ac-suffix"], true, never>;
}

interface LuxTableDoubleClickEventType<T> {
    event: MouseEvent;
    rowItem: T;
}
declare class LuxTableComponent<T = any> implements OnInit, AfterViewInit, DoCheck, OnDestroy {
    private queryObserver;
    private luxConsole;
    private liveAnnouncer;
    private tService;
    private defaultColumnVisibilityStore;
    static AUTO_PAGINATION_START: number;
    private _luxClasses;
    private _luxShowPagination;
    private _dataColumnDefs;
    private _luxMultiSelect;
    private _luxShowFilter;
    private _dataSource;
    private _luxHttpDAO?;
    private _luxPickValue;
    private _luxCompareWith;
    private previousWidth;
    private previousHeight;
    private httpRequestConf;
    private mediaQuerySubscription;
    private httpDaoSubscription?;
    private filterChangedSubscription?;
    private columnSubscriptions;
    private tableColumnsChangedSubscription?;
    private sortChangedSubscription?;
    private paginatorPageSubscription?;
    private selectedSubscription?;
    filtered$: Subject<string>;
    currentCustomClasses: {
        entry: any;
        classes: string;
    }[];
    isLoadingResults: boolean;
    allSelected: boolean;
    mediaQuery: string;
    movedTableColumns: LuxTableColumnComponent[];
    hasMovedColumnsMap: Map<string, boolean>;
    tableMinWidth?: string;
    tableHeightCSSCalc?: string;
    init: boolean;
    lastSelectedEventData: string;
    allColumnsForVisibility: {
        label: string;
        value: string;
    }[];
    hiddenColumns: string[];
    columnVisibilityPickValueFN: (option: {
        label: string;
        value: string;
    }) => string;
    luxShowColumnSelector: i0.InputSignal<boolean>;
    luxColumnStorageKey?: string;
    luxColumnVisibilityStore: ILuxTableColumnVisibilityStore;
    luxColWidthsPercent: number[];
    luxFilterText: string;
    luxNoDataText: string;
    luxPageSize: number;
    luxPageSizeOptions: number[];
    luxMinWidthPx: number;
    luxAutoPaginate: boolean;
    luxHideBorders: boolean;
    luxMultiSelectOnlyCheckboxClick: boolean;
    luxMultiSelectDisabledProperty?: string;
    luxPagerDisabled: boolean;
    luxPagerTooltip: string;
    luxPagerFirstLastButton: boolean;
    luxAlignElementsTop: boolean;
    luxSelectedChange: EventEmitter<Set<T>>;
    luxSelectedAsArrayChange: EventEmitter<T[]>;
    luxSingleClicked: EventEmitter<{
        event: Event;
        rowItem: T;
        rowIndex: number;
    }>;
    luxDoubleClicked: EventEmitter<{
        event: MouseEvent;
        rowItem: T;
    }>;
    luxHiddenColumnsChange: EventEmitter<string[]>;
    paginator?: MatPaginator;
    sort?: MatSort;
    paginatorElement?: ElementRef;
    filterElement?: ElementRef;
    filterComponent?: LuxInputAcComponent;
    tableContainerElement: ElementRef;
    tableColumns: QueryList<LuxTableColumnComponent>;
    get luxHttpDAO(): ILuxTableHttpDao | undefined;
    set luxHttpDAO(httpDAO: ILuxTableHttpDao | undefined);
    get luxClasses(): ICustomCSSConfig | ICustomCSSConfig[];
    set luxClasses(classes: ICustomCSSConfig | ICustomCSSConfig[]);
    get luxShowPagination(): boolean;
    set luxShowPagination(show: boolean);
    get luxShowFilter(): boolean;
    set luxShowFilter(show: boolean);
    get dataColumnDefs(): string[];
    get dataSource(): LuxTableDataSource<any>;
    get luxData(): any[];
    set luxData(data: any[]);
    get luxMultiSelect(): boolean;
    set luxMultiSelect(multiSelect: boolean);
    private _luxSelected;
    get luxSelected(): Set<T>;
    /**
     * Die Auswahl der selektierten Elemente ist eigentlich ein Set,
     * nimmt aber Arrays von Außen entgegen (zur Vereinfachung).
     * @param selected
     */
    set luxSelected(selected: Set<T>);
    private luxSelectedIntern;
    get luxPickValue(): (o: any) => any;
    set luxPickValue(pickFn: (o: any) => any);
    get luxCompareWith(): (o1: any, o2: any) => boolean;
    set luxCompareWith(compareFn: (o1: any, o2: any) => boolean);
    /**
     * Eigene Implementierung der Filterung für diese Tabelle.
     * Iteriert über die Values des einzelnen Objektes und prüft dann, ob der Filter-Wert irgendwo vorkommt.
     * @param data
     * @param filter
     */
    private customFilterPredicate;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    /**
     * Zieht sich die aktuellen CSS-Klassen aus den zugewiesenen
     * CSS-Klassen.
     * @param row
     * @returns string
     */
    getCustomClassesForIndex(row: any): string;
    /**
     * TrackBy-Funktion um die Tabelle etwas schneller zu machen.
     * @param index
     * @param item
     */
    trackFn(index: number, item: any): number;
    onSingleClick(event: Event, rowItem: T, rowIndex: number): void;
    onDoubleClick(event: MouseEvent, rowItem: T): void;
    /**
     * Wird beim Klick auf eine Row aufgerufen und handelt das Sichern und Entfernen von
     * selektierten Einträgen.
     * @param entry
     * @param checkboxEvent
     */
    changeSelectedEntry(entry: any, checkboxEvent?: boolean): void;
    /**
     * Selektiert/Deselektiert alle Einträge in dieser Tabelle.
     *
     * Voraussetzung dafür ist, das Multiselect aktiv ist und keine Http-Table vorliegt.
     */
    changeSelectedEntries(): void;
    private updateSelectedIntern;
    /**
     * Prüft, ob die aktuell angezeigten Einträge alle selektiert sind oder nicht.
     */
    checkFilteredAllSelected(): boolean;
    /**
     * Gibt zurück, ob irgendein Footer-Element für diese Tabelle aktuell sichtbar ist.
     */
    anyFootersAvailable(): boolean;
    /**
     * Aktualisiert die DataSource und eventuell Subscriptions sowie die CustomCSS-Classes
     * nach einer Änderung.
     * @param data
     */
    private updateDataSourceAttributes;
    /**
     * Prüft anhand der mitgegebenen Callbacks die CSS-Klassen
     * für die einzelnen Rows.
     */
    private insertCustomCSSClasses;
    /**
     * Gibt über den liveAnnouncer eine Nachricht aus, dass sich die Sortierung einer Spalte geändert hat.
     * @param sort
     */
    announceSortChange(sort: Sort): void;
    /**
     * Aktualisiert die momentan angezeigten Spalten anhand der für sie definierten
     * Responsive-Queries und Verhaltensweisen.
     */
    private updateColumnsByMediaQuery;
    /**
     * Prüft, ob die aktuelle MediaQuery mit der übergebenen MediaQuery/den übergebenen MediaQueries übereinstimmt.
     * @param responsiveAt
     */
    private doesResponsiveAtApply;
    /**
     * Durchläuft die aktuellen TableColumns und hört auf Changes in den Properties
     * der Columns und merkt sich die Subscriptions.
     */
    private updateColumnSubscriptions;
    /**
     * Triggert über das DAO die Abfrage nach neuen Daten.
     * Sendet dabei das Request-Conf Objekt, welches Informationen bzgl.
     * page, pageSize, filter, sort, order mitgibt.
     * @param filteredBy?
     * @param filteredBy
     */
    loadHttpDAOData(filteredBy?: string): void;
    /**
     * Wird aufgerufen, wenn der Sort neu zur DataSource hinzugefügt werden soll (Data wurde neu gesetzt).
     * Resettet die Pagination und aktualisiert, wenn es sich um eine asynchrone Tabelle handelt die
     * requestConf.
     */
    private handleSort;
    /**
     * Wird nach dem set von luxShowFilter aufgerufen und fängt neue Filter-Operationen ab und
     * aktualisiert dementsprechend die Daten.
     */
    private handleFilter;
    /**
     * Wird nach dem set von luxShowPagination aufgerufen und setzt, wenn es sich hier um
     * eine asynchrone Tabelle handelt eine Subscription um Pagination-Änderungen zu erhalten.
     */
    private handlePagination;
    /**
     * Erzeugt einen neuen String für die Höhenberechnung der Tabelle und setzt die Minimalbreite für die Tabelle
     * (wenn möglich).
     */
    private calculateProportions;
    /**
     * Aktualisiert die selectedEntries dieser Component anhand der aktuell gesetzten luxSelected-Elemente.
     *
     * Dabei werden die einzelnen Elemente zuerst mithilfe der luxCompareWith- und luxPickValue-Functions miteinander
     * verglichen.
     */
    private updateSelection;
    private emitSelectedEvent;
    private isEntryDisabled;
    addSelected(entry: any): void;
    deleteSelected(entry: any): void;
    clearSelected(): void;
    onHiddenColumnsChange(newHiddenColumns: string[]): void;
    private loadHiddenColumnsFromStorage;
    private updateColumnVisibilityOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTableComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTableComponent<any>, "lux-table", never, { "luxShowColumnSelector": { "alias": "luxShowColumnSelector"; "required": false; "isSignal": true; }; "luxColumnStorageKey": { "alias": "luxColumnStorageKey"; "required": false; }; "luxColumnVisibilityStore": { "alias": "luxColumnVisibilityStore"; "required": false; }; "luxColWidthsPercent": { "alias": "luxColWidthsPercent"; "required": false; }; "luxFilterText": { "alias": "luxFilterText"; "required": false; }; "luxNoDataText": { "alias": "luxNoDataText"; "required": false; }; "luxPageSize": { "alias": "luxPageSize"; "required": false; }; "luxPageSizeOptions": { "alias": "luxPageSizeOptions"; "required": false; }; "luxMinWidthPx": { "alias": "luxMinWidthPx"; "required": false; }; "luxAutoPaginate": { "alias": "luxAutoPaginate"; "required": false; }; "luxHideBorders": { "alias": "luxHideBorders"; "required": false; }; "luxMultiSelectOnlyCheckboxClick": { "alias": "luxMultiSelectOnlyCheckboxClick"; "required": false; }; "luxMultiSelectDisabledProperty": { "alias": "luxMultiSelectDisabledProperty"; "required": false; }; "luxPagerDisabled": { "alias": "luxPagerDisabled"; "required": false; }; "luxPagerTooltip": { "alias": "luxPagerTooltip"; "required": false; }; "luxPagerFirstLastButton": { "alias": "luxPagerFirstLastButton"; "required": false; }; "luxAlignElementsTop": { "alias": "luxAlignElementsTop"; "required": false; }; "luxHttpDAO": { "alias": "luxHttpDAO"; "required": false; }; "luxClasses": { "alias": "luxClasses"; "required": false; }; "luxShowPagination": { "alias": "luxShowPagination"; "required": false; }; "luxShowFilter": { "alias": "luxShowFilter"; "required": false; }; "luxData": { "alias": "luxData"; "required": false; }; "luxMultiSelect": { "alias": "luxMultiSelect"; "required": false; }; "luxSelected": { "alias": "luxSelected"; "required": false; }; "luxPickValue": { "alias": "luxPickValue"; "required": false; }; "luxCompareWith": { "alias": "luxCompareWith"; "required": false; }; }, { "luxSelectedChange": "luxSelectedChange"; "luxSelectedAsArrayChange": "luxSelectedAsArrayChange"; "luxSingleClicked": "luxSingleClicked"; "luxDoubleClicked": "luxDoubleClicked"; "luxHiddenColumnsChange": "luxHiddenColumnsChange"; }, ["tableColumns"], never, true, never>;
}

declare class LuxTextboxComponent {
    private _luxColor?;
    luxTitle: string;
    luxIcon: string;
    set luxColor(value: LuxTextboxColor | undefined);
    get luxColor(): LuxTextboxColor | undefined;
    luxHeading: number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTextboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTextboxComponent, "lux-textbox", never, { "luxTitle": { "alias": "luxTitle"; "required": false; }; "luxIcon": { "alias": "luxIcon"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; "luxHeading": { "alias": "luxHeading"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare const LuxConfigTokenService: InjectionToken<LuxComponentsConfigParameters>;
declare class LuxComponentsConfigModule {
    static forRoot(config: LuxComponentsConfigParameters): ModuleWithProviders<LuxComponentsConfigModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxComponentsConfigModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuxComponentsConfigModule, never, [typeof i1.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuxComponentsConfigModule>;
}

interface ILuxErrorPageConfig {
    iconName?: string;
    iconSize?: '1x' | '2x' | '3x' | '4x' | '5x';
    errorText?: string;
    homeRedirectText?: string;
    homeRedirectUrl?: string;
    errorPageUrl?: string;
    skipLocationChange?: boolean;
}

interface ILuxError {
    errorId: any;
    errorMessage: string;
}

declare class LuxErrorPageComponent {
    private router;
    private errorStore;
    get error(): ILuxError | null;
    get errorConfig(): ILuxErrorPageConfig;
    /**
     * Navigiert über den Router zum eingetragenen Home-Pfad
     */
    clickHomeRedirect(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxErrorPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxErrorPageComponent, "lux-error-page", never, {}, {}, never, never, true, never>;
}

declare class LuxErrorService {
    private router;
    private errorStore;
    constructor();
    /**
     * Überschreibt die aktuelle Konfiguration für die Fehlerseite.
     * Übernimmt so viele Werte wie möglich aus der übergebenen Konfiguration,
     * sonst werden die Default-Werte genutzt.
     * @param luxErrorPageConfig
     */
    setConfig(luxErrorPageConfig: ILuxErrorPageConfig | null): void;
    /**
     * Navigiert zur Fehlerkomponente und versucht einen Fehler
     * (wenn mitgegeben) zu sichern.
     * @param error
     * @returns Observable<any>
     */
    navigateToErrorPage(error?: ILuxError): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxErrorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxErrorService>;
}

/**
 * Dieser Service dient dazu, die aktuellen Fehlermeldungen und die Error-Page Konfiguration zu speichern.
 *
 * Er wird von LuxErrorService und LuxErrorPageComponent benutzt, ohne ihn gäbe es Cycle-Dependency Fehler.
 */
declare class LuxErrorStoreService {
    /**
     * Enthält die normale Konfiguration der Fehlerseite, kann bei Bedarf mit setConfig überschrieben werden.
     */
    static readonly DEFAULT_CONFIG: ILuxErrorPageConfig;
    private _config;
    private _error;
    private _lastErrors;
    /**
     * Gibt die aktuelle Konfiguration zurück.
     * @returns ILuxErrorPageConfig
     */
    get config(): ILuxErrorPageConfig;
    /**
     * Gibt ein Array der letzten Fehler zurück.
     * @returns Array<ILuxError[]>
     */
    get lastErrors(): ILuxError[][];
    /**
     * Gibt den aktuellen Fehler zurück.
     * @returns ILuxError
     */
    get error(): ILuxError | null;
    /**
     * Sichert den Fehler in der Property und fügt ihn der "lastErrors"-Liste hinzu.
     * @param newError
     */
    set error(newError: ILuxError | null);
    constructor();
    /**
     * Initialisiert den Service.
     */
    init(): void;
    /**
     * Diese Methode sichert die übergebene Konfiguration.
     * @param luxErrorPageConfig
     */
    safeNewConfig(luxErrorPageConfig: ILuxErrorPageConfig | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxErrorStoreService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxErrorStoreService>;
}

declare class LuxHttpErrorInterceptor implements HttpInterceptor {
    static dataStream: ReplaySubject<any>;
    constructor();
    static dataStream$(): Observable<any>;
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static extractErrors(error: any | null): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxHttpErrorInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxHttpErrorInterceptor>;
}

declare class LuxHttpErrorComponent implements OnInit, OnDestroy, AfterViewInit {
    messageComponent: LuxMessageBoxComponent;
    luxMessageBoxClosed: EventEmitter<void>;
    private subs;
    errors: ILuxMessage[];
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Updated das aktuelle Errors-Array mit dem übergebenen Wert.
     * Liest dabei die Message aus dem Fehler und erzeugt LuxMessage-Objekte für die LuxMessageBoxComponent.
     * @param errors
     */
    private updateErrors;
    /**
     * Versucht eine Fehlermeldung aus dem Fehler zu lesen.
     * Zuerst wird geschaut, ob der Fehler selbst nur ein String ist. Wenn ja, diesen zurückgeben.
     * Dann wird geprüft, ob der Fehler eine "message"-Property besitzt. Wenn ja, diese zurückgeben.
     * Als letzter Ausweg wird das "error"-Objekt selbst über die toString-Methode zurückgegeben.
     * @param error
     */
    private static readErrorMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxHttpErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxHttpErrorComponent, "lux-http-error", never, {}, { "luxMessageBoxClosed": "luxMessageBoxClosed"; }, never, never, true, never>;
}

declare class LuxAutocompleteAcComponent<V = any, O = any> extends LuxFormComponentBase<V> implements OnInit, OnDestroy, AfterViewInit {
    tservice: TranslocoService;
    private selected$;
    private subscriptions;
    private valueChangeSubscription?;
    filteredOptions: O[];
    displayedOptions: O[];
    loadingRunning: boolean;
    activeIndex: number;
    focused: boolean;
    _luxOptions: O[];
    autoFillObserver: MutationObserver;
    luxPlaceholder: string;
    luxOptionLabelProp: string;
    luxLookupDelay: number;
    luxErrorMessageNotAnOption: string;
    luxTagId?: string;
    luxSelectAllOnClick: boolean;
    luxStrict: boolean;
    luxName?: string;
    luxPickValue?: ((selected: O | null | undefined) => V) | undefined;
    luxFilterFn?: (filterTerm: string, label: string, option: any) => boolean;
    luxPanelWidth: string | number;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    luxOptionBlockSize: number;
    luxValueChange: EventEmitter<V | null>;
    luxOptionSelected: EventEmitter<V | null>;
    luxBlur: EventEmitter<FocusEvent>;
    luxFocus: EventEmitter<FocusEvent>;
    labelTemplate?: TemplateRef<any>;
    inputPrefix?: LuxInputAcPrefixComponent;
    inputSuffix?: LuxInputAcSuffixComponent;
    matAutoComplete: MatAutocompleteTrigger;
    matInput: ElementRef;
    matAutocompleteComponent: MatAutocomplete;
    get luxValue(): V;
    set luxValue(value: V);
    get luxOptions(): O[];
    set luxOptions(options: O[]);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    /**
     * Stößt das Nachladen von Elementen an, wenn ein bestimmter Scrollwert erreicht wurde.
     * @param event - ScrollEvent
     */
    private loadOnScroll;
    /**
     * Läd den nächsten Block Daten aus den Entries nach.
     */
    updateDisplayedEntries(): void;
    /**
     * @override
     * @param value
     * @param errors
     */
    errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    /**
     * Regelt die Darstellung der gewählten Option im Normalfall.
     * (Ausnahme: Focus-Verlust)
     * @param value
     * @returns string
     */
    displayFn(value: any): string;
    /**
     * Filtert das Options-Array nach dem filterTerm und
     * gibt das Ergebnis als Array zurück.
     * @param filterTerm
     * @returns any[]
     */
    filter(filterTerm: any): O[];
    /**
     * Click-Event Handling
     * selektiert den gesamten Text im Input, wenn selectAllOnClick = true ist.
     * @param clickEvent
     */
    onClick(clickEvent: any): void;
    /**
     * Gibt den darzustellenden Wert einer Option bzw.
     * die Option selbst (wenn string) wider.
     * @param option
     * @returns any
     */
    getOptionLabel(option: any): any;
    selected(selectedEvent: MatAutocompleteSelectedEvent): void;
    onFocus(e: FocusEvent): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    private handleErrors;
    private handleOtherErrors;
    private handleIncorrectError;
    notifyFormValueChanged(formValue: any): void;
    private getPickValueOption;
    private updateFilterOptions;
    private registerNewValueChangesListener;
    private filterOptions;
    private updateFormControlValue;
    /**
     * Wrapper-Klick: Fokus setzen und Panel öffnen (falls erlaubt).
     * Verwendet mousedown statt click, um Event-Bubbling nicht zu stören.
     */
    onWrapperClick(event: MouseEvent): void;
    /**
     * Durch diese track-Funktion wird der folgendfe Fehler vermieden:
     * NG0955: The provided track expression resulted in duplicated keys for a given collection.
     *
     * @param index
     * @param option
     * @returns
     */
    trackOption(index: number, option: O): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAutocompleteAcComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAutocompleteAcComponent<any, any>, "lux-autocomplete-ac", never, { "luxPlaceholder": { "alias": "luxPlaceholder"; "required": false; }; "luxOptionLabelProp": { "alias": "luxOptionLabelProp"; "required": false; }; "luxLookupDelay": { "alias": "luxLookupDelay"; "required": false; }; "luxErrorMessageNotAnOption": { "alias": "luxErrorMessageNotAnOption"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxSelectAllOnClick": { "alias": "luxSelectAllOnClick"; "required": false; }; "luxStrict": { "alias": "luxStrict"; "required": false; }; "luxName": { "alias": "luxName"; "required": false; }; "luxPickValue": { "alias": "luxPickValue"; "required": false; }; "luxFilterFn": { "alias": "luxFilterFn"; "required": false; }; "luxPanelWidth": { "alias": "luxPanelWidth"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; "luxOptionBlockSize": { "alias": "luxOptionBlockSize"; "required": false; }; "luxValue": { "alias": "luxValue"; "required": false; }; "luxOptions": { "alias": "luxOptions"; "required": false; }; }, { "luxValueChange": "luxValueChange"; "luxOptionSelected": "luxOptionSelected"; "luxBlur": "luxBlur"; "luxFocus": "luxFocus"; }, ["labelTemplate", "inputPrefix", "inputSuffix"], ["lux-input-ac-prefix", "lux-input-ac-suffix"], true, never>;
}

/**
 * Basis-Klasse für FormComponents, die einen ähnlichen Grundaufbau für das Aktivieren eines Boolean-Wertes besitzen
 * (LuxToggle und LuxCheckbox z.B.).
 */
declare abstract class LuxFormCheckableBaseClass<T> extends LuxFormComponentBase<T> {
    luxCheckedChange: EventEmitter<boolean>;
    luxTagId?: string;
    get luxChecked(): T;
    set luxChecked(checked: T);
    notifyFormValueChanged(formValue: boolean): void;
    errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    protected checkValidatorsContainRequired(validators: ValidatorFnType): ValidatorFnType;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormCheckableBaseClass<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFormCheckableBaseClass<any>, never, never, { "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxChecked": { "alias": "luxChecked"; "required": false; }; }, { "luxCheckedChange": "luxCheckedChange"; }, never, never, true, never>;
}

declare class LuxCheckboxAcComponent<T = boolean> extends LuxFormCheckableBaseClass<T> implements OnInit {
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    focused: boolean;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCheckboxAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCheckboxAcComponent<any>, "lux-checkbox-ac", never, { "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxChipAcGroupComponent {
    private _luxColor;
    tempRef?: TemplateRef<any>;
    luxChipClicked: EventEmitter<number>;
    luxChipAdded: EventEmitter<string>;
    luxChipRemoved: EventEmitter<number>;
    luxLabels: string[];
    luxDisabled: boolean;
    luxRemovable: boolean;
    get luxColor(): LuxThemePalette;
    set luxColor(color: LuxThemePalette);
    constructor();
    add(label: string): void;
    remove(index: number): void;
    click(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxChipAcGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxChipAcGroupComponent, "lux-chip-ac-group", never, { "luxLabels": { "alias": "luxLabels"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxRemovable": { "alias": "luxRemovable"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; }, { "luxChipClicked": "luxChipClicked"; "luxChipAdded": "luxChipAdded"; "luxChipRemoved": "luxChipRemoved"; }, ["tempRef"], never, true, never>;
}

declare class LuxChipAcComponent implements AfterViewInit {
    private removeClicked;
    private _luxColor;
    templateRef: TemplateRef<any>;
    luxChipRemoved: EventEmitter<number>;
    luxChipClicked: EventEmitter<number>;
    luxDisabled: boolean;
    luxRemovable: boolean;
    get luxColor(): LuxThemePalette;
    set luxColor(color: LuxThemePalette);
    constructor();
    ngAfterViewInit(): void;
    remove(index: number): void;
    click(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxChipAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxChipAcComponent, "lux-chip-ac", never, { "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxRemovable": { "alias": "luxRemovable"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; }, { "luxChipRemoved": "luxChipRemoved"; "luxChipClicked": "luxChipClicked"; }, never, ["*"], true, never>;
}

declare type LuxChipsAcOrientation = 'horizontal' | 'vertical';
declare class LuxChipsAcComponent extends LuxFormComponentBase<string[]> implements OnInit, AfterContentInit, AfterViewInit, OnDestroy {
    private subscriptions;
    private _luxAutocompleteOptions;
    uid: string;
    _filteredOptions: string[];
    displayedOptions: string[];
    loadingRunning: boolean;
    activeIndex: number;
    onInitFinished: boolean;
    get filteredOptions(): string[];
    set filteredOptions(newOptions: string[]);
    inputValue$: Subject<string>;
    newChip$: Subject<any>;
    canClose: boolean;
    actionRunning: boolean;
    initRunning: boolean;
    luxOrientation: LuxChipsAcOrientation;
    luxInputAllowed: boolean;
    luxNewChipGroup?: LuxChipAcGroupComponent;
    luxStrict: boolean;
    luxLabelLongFormat: boolean;
    luxPlaceholder: string;
    luxOptionBlockSize: number;
    luxHideBorder: boolean;
    luxInputLabelAlwaysVisible: boolean;
    luxChipAdded: EventEmitter<string>;
    luxChipComponents: QueryList<LuxChipAcComponent>;
    luxChipGroupComponents: QueryList<LuxChipAcGroupComponent>;
    matChips: QueryList<MatChip>;
    chipRowElements: QueryList<ElementRef<HTMLElement>>;
    chipTooltips: QueryList<LuxTooltipDirective>;
    matInput: ElementRef;
    matAutocompleteTrigger?: MatAutocompleteTrigger;
    matAutocomplete?: MatAutocomplete;
    matAutocompleteComponent?: MatAutocomplete;
    chipContainerDivRef: ElementRef;
    get luxDisabled(): boolean;
    set luxDisabled(disabled: boolean);
    get luxAutocompleteOptions(): string[];
    set luxAutocompleteOptions(options: string[]);
    get luxInputLabel(): string;
    set luxInputLabel(label: string);
    get chipComponents(): LuxChipAcComponent[];
    get chipGroupComponents(): LuxChipAcGroupComponent[];
    constructor();
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    private updateChipTooltips;
    /**
     * Stößt das Nachladen von Elementen an, wenn ein bestimmter Scrollwert erreicht wurde.
     * @param event - ScrollEvent
     */
    private loadOnScroll;
    /**
     * Läd den nächsten Block Daten aus den Entries nach.
     */
    updateDisplayedEntries(): void;
    ngOnDestroy(): void;
    /**
     * Fügt einen Chip hinzu.
     * Fügt ihn entweder der explizit mitgeteilten newChipList hinzu oder einfach
     * der letzten mitgegebenen Liste.
     * @param value
     */
    add(value: string): void;
    onFocusOut(): void;
    onChipGroupRemove(chipGroup: LuxChipAcGroupComponent, index: number): void;
    /**
     * Wird bei Eingabe von Werten in das Input-Feld aufgerufen und schreibt einen neuen Wert
     * in das inputValue-Subject.
     * @param value
     */
    inputChanged(value: string): void;
    /**
     * Diese Methode öffnet bei jedem Klick das Optionspanel des
     * Autocomplete-Feldes.
     *
     * Details:
     * Im Standard wird das Optionspanel eines Autocomplete-Feldes nur einmal
     * geöffnet. Ein Autocomplete-Feld prüft bei jedem Klick, ob es selbst den
     * Fokus hat und ob sein Optionspanel bereits zuvor geöffnet wurde. Wenn beide
     * Bedingungen zutreffen, bleibt das Optionspanel beim erneuten Klicken
     * standardmäßig geschlossen. Hier bei den Chips soll das Verhalten des
     * Autocomplete-Feldes geändert werden. Jeder Klick soll immer das
     * Optionspanel öffnen, unabhängig von irgendwelchen Bedingungen. Dadurch
     * können die Benutzer auch mit der Maus mehrere Chips hintereinander
     * auswählen.
     */
    onAutocompleteClick(): void;
    /**
     * Wird beim Selektieren einer Option im Autocomplete ausgeführt.
     * @param input
     * @param value
     */
    autoCompleteAdd(input: HTMLInputElement, value: string): void;
    /**
     * Wird beim Input-Event des Eingabefelds ausgeführt, fragt aber vorher ab, ob das Autocomplete offen ist.
     * Wenn ja, wird kein neuer Chip erzeugt, da das Autocomplete dies übernimmt.
     * @param input
     */
    inputAdd(input: HTMLInputElement): void;
    onAutoCompleteOpened(): void;
    onArrowIcon(): void;
    protected initFormControl(): void;
    protected notifyFormValueChanged(formValue: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxChipsAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxChipsAcComponent, "lux-chips-ac", never, { "luxOrientation": { "alias": "luxOrientation"; "required": false; }; "luxInputAllowed": { "alias": "luxInputAllowed"; "required": false; }; "luxNewChipGroup": { "alias": "luxNewChipGroup"; "required": false; }; "luxStrict": { "alias": "luxStrict"; "required": false; }; "luxLabelLongFormat": { "alias": "luxLabelLongFormat"; "required": false; }; "luxPlaceholder": { "alias": "luxPlaceholder"; "required": false; }; "luxOptionBlockSize": { "alias": "luxOptionBlockSize"; "required": false; }; "luxHideBorder": { "alias": "luxHideBorder"; "required": false; }; "luxInputLabelAlwaysVisible": { "alias": "luxInputLabelAlwaysVisible"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxAutocompleteOptions": { "alias": "luxAutocompleteOptions"; "required": false; }; "luxInputLabel": { "alias": "luxInputLabel"; "required": false; }; }, { "luxChipAdded": "luxChipAdded"; }, ["luxChipComponents", "luxChipGroupComponents"], never, true, never>;
}

import DateTimeFormatOptions = Intl.DateTimeFormatOptions;

declare class LuxDatepickerAcAdapter extends NativeDateAdapter {
    private readonly dotRegExp;
    private readonly backslashRegExp;
    private readonly hyphenRegExp;
    private readonly hyphenRegExp_1;
    private readonly noSeparatorRegExp;
    format(date: Date | string, displayFormat: DateTimeFormatOptions): string;
    parse(value: string): Date | null;
    getFirstDayOfWeek(): number;
    /**
     * UTC Date mit 0-Werten für Time aus einem ddMMYYYY-String erhalten.
     * @param dateString
     * @param separator
     */
    private getUTCNulled_ddMMYYYY;
    /**
     * UTC Date mit 0-Werten für Time aus einem ddMMYYYY-String erhalten.
     * @param dateString
     */
    private getUTCNulled_ddMMYYYYNoSeparator;
    /**
     * UTC Date mit 0-Werten für Time aus einem YYYYMMdd-String erhalten.
     * @param dateString
     * @param separator
     */
    private getUTCNulled_YYYYMMdd;
    /**
     * UTC Date mit 0-Werten für Time aus einem MMddYYYY-String erhalten.
     * @param dateString
     * @param separator
     */
    private getUTCNulled_MMddYYY;
    isValid(date: any): any;
    private calculateMonth;
    private isValidYear;
    getDayOfWeekNames(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDatepickerAcAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxDatepickerAcAdapter>;
}

declare class LuxDatepickerAcCustomHeaderComponent<D> implements OnDestroy {
    private _calendar;
    private _dateAdapter;
    private _dateFormats;
    private _destroyed;
    constructor();
    ngOnDestroy(): void;
    get periodLabel(): string;
    previousClicked(mode: 'month' | 'year'): void;
    nextClicked(mode: 'month' | 'year'): void;
    currentPeriodClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDatepickerAcCustomHeaderComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDatepickerAcCustomHeaderComponent<any>, "lux-datepicker-ac-custom-header", never, {}, {}, never, never, true, never>;
}

declare const APP_DATE_FORMATS_AC: {
    parse: {
        dateInput: {
            month: string;
            year: string;
            day: string;
        };
    };
    display: {
        dateInput: {
            month: string;
            year: string;
            day: string;
        };
        monthYearLabel: {
            year: string;
            month: string;
        };
        dateA11yLabel: {
            year: string;
            month: string;
            day: string;
        };
        monthYearA11yLabel: {
            year: string;
            month: string;
        };
    };
};
declare type LuxDateFilterAcFn = (date: Date | null) => boolean;
declare type LuxStartAcView = 'month' | 'year' | 'multi-year';
declare class LuxDatepickerAcComponent<T = any> extends LuxFormInputBaseClass<T> implements OnInit, OnChanges, OnDestroy {
    private dateAdapter;
    private mediaObserver;
    private elementRef;
    private themeService;
    private originalTouchUi;
    private mediaSubscription?;
    private previousISO?;
    min: Date | null;
    max: Date | null;
    start: Date | null;
    focused: boolean;
    _luxCustomFilter: LuxDateFilterAcFn;
    luxStartView: LuxStartAcView;
    luxTouchUi: boolean;
    luxOpened: boolean;
    luxStartDate: string | null;
    luxShowToggle: boolean;
    luxMaxDate: string | null;
    luxMinDate: string | null;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    matDatepicker?: MatDatepicker<any>;
    datepickerInput?: ElementRef;
    luxLocale: i0.WritableSignal<string>;
    get luxCustomFilter(): LuxDateFilterAcFn | undefined;
    set luxCustomFilter(customFilterFn: LuxDateFilterAcFn | undefined);
    get luxValue(): T;
    set luxValue(value: T);
    get dateInputValue(): string;
    set dateInputValue(newValue: string);
    constructor();
    ngOnChanges(simpleChanges: SimpleChanges): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Erzeugt für die Unter- bzw. Überschreitung
     * @param value
     * @param errors
     */
    errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    onFocus(e: FocusEvent): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    /**
     * Checkt, ob eine mobile Media-Query vorliegt.
     * Wenn ja, wird automatisch die TouchUI aktiviert.
     * Wenn nein, wird der vom Aufrufer/originale luxTouchUI-Wert genutzt.
     */
    private checkMediaObserver;
    /**
     * Führt .open() bzw. .close() vom MatDatepicker aus, abhängig vom Wert für luxOpened.
     */
    private triggerOpenClose;
    /**
     * Aktualisiert den FormControl-Value und den Wert im Parent über valueChange mithilfe des übergebenen ISO-Strings.
     * @param isoValue
     */
    private setISOValue;
    protected setValue(value: any): void;
    protected initFormValueSubscription(): void;
    private updateDateValue;
    getHeaderByTheme(): any;
    private formatDateTime;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDatepickerAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDatepickerAcComponent<any>, "lux-datepicker-ac", never, { "luxStartView": { "alias": "luxStartView"; "required": false; }; "luxTouchUi": { "alias": "luxTouchUi"; "required": false; }; "luxOpened": { "alias": "luxOpened"; "required": false; }; "luxStartDate": { "alias": "luxStartDate"; "required": false; }; "luxShowToggle": { "alias": "luxShowToggle"; "required": false; }; "luxMaxDate": { "alias": "luxMaxDate"; "required": false; }; "luxMinDate": { "alias": "luxMinDate"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; "luxCustomFilter": { "alias": "luxCustomFilter"; "required": false; }; "luxValue": { "alias": "luxValue"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxDatetimeOverlayContentAcComponent implements OnInit, AfterViewInit {
    private elementRef;
    private themeService;
    hoursInputComponent: LuxInputAcComponent;
    minutesInputComponent: LuxInputAcComponent;
    dateTimePicker: LuxDatetimeOverlayAcComponent;
    selected: Date | null;
    startDate: Date | null;
    minCalendarDate: Date | null;
    maxCalendarDate: Date | null;
    _hours: string;
    _minutes: string;
    touched: boolean;
    customHeader?: ComponentType<any>;
    get hours(): string;
    set hours(hours: string);
    get minutes(): string;
    set minutes(minutes: string);
    initDate(value?: string): void;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    incrementHour(): void;
    decrementHour(): void;
    incrementMinutes(): void;
    decrementMinutes(): void;
    fillHours(): void;
    fillMinutes(): void;
    onOk(): void;
    selectHours(): void;
    selectMinutes(): void;
    getHeaderByTheme(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDatetimeOverlayContentAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDatetimeOverlayContentAcComponent, "lux-datetime-overlay-content-ac", never, {}, {}, never, never, true, never>;
}

declare class LuxDatetimeOverlayAcComponent {
    private elementRef;
    private ngZone;
    private overlay;
    private viewContainerRef;
    private document;
    private _dir;
    private _formField;
    luxPickerInput: HTMLInputElement;
    luxStartView: 'month' | 'year' | 'multi-year';
    luxStartDate: Date | null;
    luxStartTime: number[];
    luxMinDate: Date | null;
    luxMaxDate: Date | null;
    luxSelected: EventEmitter<Date>;
    openedStream: EventEmitter<void>;
    closedStream: EventEmitter<void>;
    stateChanges: Subject<void>;
    hasBackdrop: boolean;
    opened: boolean;
    scrollStrategy: () => ScrollStrategy;
    _selectedDate?: string;
    _luxCustomFilter: LuxDateFilterAcFn;
    id: string;
    disabled: boolean;
    color: LuxThemePalette;
    registerInput(input: any): MatDateSelectionModel<any>;
    get luxCustomFilter(): LuxDateFilterAcFn | undefined;
    set luxCustomFilter(customFilterFn: LuxDateFilterAcFn | undefined);
    get selectedDate(): string | undefined;
    set selectedDate(date: string | undefined);
    dateTimePortal?: ComponentPortal<LuxDatetimeOverlayContentAcComponent>;
    lastFocusedElement: Element | null;
    overlayRef?: OverlayRef;
    overlayComponentRef?: ComponentRef<LuxDatetimeOverlayContentAcComponent> | null;
    datepickerInput: any;
    constructor();
    onOk(date: Date): void;
    open(): void;
    private openOverlay;
    private createOverlay;
    cancel(): void;
    close(): void;
    private _createOverlayPositionStrategy;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDatetimeOverlayAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDatetimeOverlayAcComponent, "lux-datetime-overlay-ac", never, { "luxPickerInput": { "alias": "luxPickerInput"; "required": false; }; "luxStartView": { "alias": "luxStartView"; "required": false; }; "luxStartDate": { "alias": "luxStartDate"; "required": false; }; "luxStartTime": { "alias": "luxStartTime"; "required": false; }; "luxMinDate": { "alias": "luxMinDate"; "required": false; }; "luxMaxDate": { "alias": "luxMaxDate"; "required": false; }; "luxCustomFilter": { "alias": "luxCustomFilter"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; }, { "luxSelected": "luxSelected"; "openedStream": "openedStream"; "closedStream": "closedStream"; }, never, never, true, never>;
}

declare class LuxDateTimePickerAcAdapter extends NativeDateAdapter {
    private readonly dotRegExp;
    private readonly backslashRegExp;
    private readonly hyphenRegExp;
    private readonly hyphenRegExp_1;
    private readonly noSeparatorRegExp;
    format(date: Date | string, displayFormat: object): string;
    parse(dateAsString: string): Date | null;
    getFirstDayOfWeek(): number;
    getDayOfWeekNames(): string[];
    /**
     * UTC Date mit 0-Werten für Time aus einem ddMMYYYY-String erhalten.
     * @param dateString
     * @param timeString
     * @param separator
     */
    private getUTCNulled_ddMMYYYY;
    /**
     * UTC Date mit 0-Werten für Time aus einem YYYYMMdd-String erhalten.
     * @param dateString
     * @param timeString
     * @param separator
     */
    private getUTCNulled_YYYYMMdd;
    /**
     * UTC Date mit 0-Werten für Time aus einem MMddYYYY-String erhalten.
     * @param dateString
     * @param timeString
     * @param separator
     */
    private getUTCNulled_MMddYYY;
    /**
     * UTC Date mit 0-Werten für Time aus einem ddMMYYYY-String erhalten.
     * @param dateString
     * @param timeString
     */
    private getUTCNulled_ddMMYYYYNoSeparator;
    isValid(date: any): any;
    private calculateMonth;
    private isValidYear;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDateTimePickerAcAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxDateTimePickerAcAdapter>;
}

declare const APP_DATE_TIME_FORMATS_AC: {
    parse: {
        dateInput: {
            month: string;
            year: string;
            day: string;
            hour: string;
            minute: string;
            hour12: boolean;
        };
    };
    display: {
        dateInput: {
            month: string;
            year: string;
            day: string;
            hour: string;
            minute: string;
            hour12: boolean;
        };
        monthYearLabel: {
            year: string;
            month: string;
        };
        dateA11yLabel: {
            year: string;
            month: string;
            day: string;
        };
        monthYearA11yLabel: {
            year: string;
            month: string;
        };
    };
};
declare class LuxDatetimepickerAcComponent<T = any> extends LuxFormInputBaseClass<T> implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    private dateTimeAdapter;
    dateTimeOverlayComponent?: LuxDatetimeOverlayAcComponent;
    dateTimePickerInputEl: ElementRef;
    luxStartView: LuxStartAcView;
    luxOpened: boolean;
    luxStartDate?: string;
    luxStartTime: number[];
    luxShowToggle: boolean;
    luxCustomFilter?: LuxDateFilterAcFn;
    luxMaxDate?: string;
    luxMinDate?: string;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    luxLocale: i0.WritableSignal<string>;
    dateTimeValidator: ValidatorFn;
    min: Date | null;
    max: Date | null;
    start: Date | null;
    focused: boolean;
    get selectedDate(): string | undefined;
    get dateTimeInputValue(): string;
    set dateTimeInputValue(newValue: string);
    constructor();
    getStartValue(): string | undefined;
    getThemePalette(): LuxThemePalette;
    disabled: boolean;
    dateFilter?: DateFilterFn<any>;
    getConnectedOverlayOrigin(): ElementRef;
    getOverlayLabelId(): null;
    stateChanges?: Observable<void>;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    ngAfterViewInit(): void;
    onOk(date: Date): void;
    onFocus(e: FocusEvent): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(event: FocusEvent): void;
    descripedBy(): string | undefined;
    errorMessageModifier(_value: any, errors: LuxValidationErrors): string | undefined;
    protected setValue(value: any): void;
    protected initFormValueSubscription(): void;
    protected updateValidators(validators: ValidatorFnType, checkRequiredValidator: boolean): void;
    private compareDateWithTime;
    private setISOValue;
    private triggerOpenClose;
    private formatDateTime;
    private parseDateTime;
    private updateDateValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDatetimepickerAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDatetimepickerAcComponent<any>, "lux-datetimepicker-ac", never, { "luxStartView": { "alias": "luxStartView"; "required": false; }; "luxOpened": { "alias": "luxOpened"; "required": false; }; "luxStartDate": { "alias": "luxStartDate"; "required": false; }; "luxStartTime": { "alias": "luxStartTime"; "required": false; }; "luxShowToggle": { "alias": "luxShowToggle"; "required": false; }; "luxCustomFilter": { "alias": "luxCustomFilter"; "required": false; }; "luxMaxDate": { "alias": "luxMaxDate"; "required": false; }; "luxMinDate": { "alias": "luxMinDate"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, never, never, true, never>;
}

interface ILuxFileObject {
    name: string;
    type: string;
    size?: number;
    content?: string | Blob;
    contentCallback?: Promise<any> | Observable<any> | any;
    namePrefix?: string;
    namePrefixColor?: string;
    nameSuffix?: string;
    nameSuffixColor?: string;
}

interface ILuxFileActionBaseConfig {
    hidden: boolean;
    disabled: boolean;
    iconName: string;
    label: string;
    prio?: number;
}
interface ILuxFileActionConfig extends ILuxFileActionBaseConfig {
    onClick?: (file: ILuxFileObject) => void;
}
interface ILuxFilesActionConfig extends ILuxFileActionBaseConfig {
    onClick?: (files: ILuxFileObject[]) => void;
}

declare enum LuxFileErrorCause {
    MaxSizeError = "luxMaximumSize",
    MaxFileCount = "luxMaxFileCount",
    ReadingFileError = "luxReadingFile",
    UploadFileError = "luxUploadFile",
    FileNotAccepted = "luxUnacceptedFile",
    MultipleForbidden = "luxMultipleForbidden"
}
interface ILuxFileError {
    cause: LuxFileErrorCause;
    exception: any;
    file?: File;
}

declare abstract class LuxFormFileBase<T = any> extends LuxFormComponentBase<T> {
    protected http: HttpClient;
    protected liveAnnouncer: LiveAnnouncer;
    defaultReadFileDelay: number;
    private _luxAccept;
    protected _luxCustomActionConfigs: ILuxFileActionConfig[];
    progress: number;
    forceProgressIndeterminate: boolean;
    displayClearErrorButton: boolean;
    downloadLink: ElementRef;
    fileUploadInput: ElementRef;
    luxSelectedChange: EventEmitter<T>;
    luxUploadReportProgress: boolean;
    luxContentsAsBlob: boolean;
    luxTagId?: string;
    luxMaxSizeMB: number;
    luxMaxFileCount: number;
    luxCapture: string;
    luxUploadUrl: string;
    luxDnDActive: boolean;
    luxMaximumExtended: number;
    isDragActive: boolean;
    onDragOver(dragEvent: DragEvent): void;
    onDragLeave(dragEvent: DragEvent): void;
    onDrop(dragEvent: DragEvent): void;
    get luxCustomActionConfigs(): ILuxFileActionConfig[];
    set luxCustomActionConfigs(config: ILuxFileActionConfig[]);
    get luxSelected(): T;
    set luxSelected(selectedFiles: T);
    get luxAccept(): any;
    set luxAccept(accepts: any);
    get progressMode(): LuxProgressModeType;
    get isProgressVisible(): boolean;
    /**
     * Wird beim Fokussieren des Elements aufgerufen und markiert das FormControl als "touched".
     * @param focusEvent
     */
    onFocusIn(focusEvent: FocusEvent): void;
    /**
     * Löst den Download der übergebenen Datei aus.
     * @param file
     */
    downloadFile(file: ILuxFileObject | ILuxFileObject[]): void;
    /**
     * Löst den base64Callback der übergebenen Datei aus.
     * Schreibt dann anschließend den Base64-String in die Datei.
     * @param file
     */
    viewFile(file: ILuxFileObject): void;
    /**
     * Wandelt File-Objekt zu LuxFileObjects um und versucht diese hochzuladen.
     * Gibt ein Promise mit den neuen FileObjects zurück bzw. einen Fehler aus den internen Promises.
     * @param files
     */
    updateSelectedFiles(files: FileList | File[]): Promise<ILuxFileObject[]>;
    /**
     * Stößt das Hochladen der Dateien zu einer bestimmten URL an.
     * @param files
     */
    uploadFiles(files: ILuxFileObject[] | ILuxFileObject | null): Promise<void>;
    /**
     * Liest die übergebenen Dateien aus und erzeugt daraus ein Promise, welches abgefragt werden kann.
     * Fängt potenzielle Fehler ab und gibt diese als abgelehnte Promises zurück.
     * @param files
     */
    mapFilesToFileObjects(files: FileList | File[]): Promise<ILuxFileObject[]>;
    /**
     * Liest (asynchron) den Base64-String aus der übergebenen Datei heraus bzw. gibt den Fehler zurück, wenn einer
     * aufgetreten ist.
     * @param file
     */
    readFile(file: File): Promise<unknown>;
    /**
     * Wird beim Drag-Over über dem LuxFormControl aufgerufen.
     * @param dragEvent
     */
    handleDragOver(dragEvent: DragEvent): void;
    /**
     * Wird beim Drag-Leave über dem LuxFormControl aufgerufen.
     * @param dragEvent
     */
    handleDragLeave(dragEvent: DragEvent): void;
    /**
     * Wird beim Drop eines/mehrerer gezogener Elemente über dem LuxFormControl aufgerufen und löst
     * die Auswahl-Methoden für die entsprechenden Dateien aus.
     * @param dragEvent
     */
    handleDrop(dragEvent: DragEvent): void;
    logError(error: any): void;
    abstract selectFiles(files: FileList | File[]): void;
    abstract resetSelected(): void;
    abstract handleUploadClick(files: ILuxFileObject[]): void;
    abstract handleDownloadClick(file: ILuxFileObject): void;
    abstract handleViewFileClick(file: ILuxFileObject): void;
    /**
     * Entfernt die in dieser Component gesetzten Fehlermeldungen.
     */
    protected clearFormControlErrors(): void;
    /**
     * Aktualisiert das Fehlerobjekt am FormControl, damit eine entsprechende Fehlermeldung angezeigt werden kann.
     * Leert die Anzeige und gibt Events mit leerem Array aus.
     * @param error
     */
    protected setFormControlErrors(error: ILuxFileError): void;
    /**
     * Berechnet die Größe der übergebenen Datei in MB.
     * @param file
     */
    protected getFileSizeInMB(file: File): number;
    /**
     * Gibt die Message für Überschreitung der maximalen Dateigröße zurück.
     * @param file
     */
    protected getMaxSizeErrorMessage(file: File): string;
    /**
     * Gibt die Message für Überschreitung der maximalen Dateianzahl zurück.
     * @param file
     */
    protected getMaxFileCountMessage(): string;
    /**
     * Gibt die Message für Fehler beim Auslesen einer Datei zurück.
     * @param file
     */
    protected getReadingFileErrorMessage(file: File): string;
    /**
     * Gibt die Message für Fehler beim Upload einer Datei zurück.
     * @param files
     */
    protected getUploadFileErrorMessage(files: File[]): string;
    /**
     * Gibt die Message für falsche Dateitypen zurück.
     * @param file
     */
    protected getFileNotAcceptedMessage(file: File): string;
    /**
     * Gibt die Message für falsche Dateitypen zurück.
     */
    protected getMultipleForbiddenMessage(): string;
    /**
     * Meldet dem ScreenReader, dass gerade eine/mehrere Dateien bearbeitet werden (Ladeanzeige).
     * @param multiple
     */
    protected announceFileProcess(multiple: boolean): void;
    /**
     * Meldet dem ScreenReader, dass alle Dateien entfernt werden sollen.
     */
    protected announceAllFilesRemove(): void;
    /**
     * Meldet dem ScreenReader, dass eine bestimmte Datei entfernt werden soll.
     * @param fileName
     */
    protected announceFileRemove(fileName: string): void;
    /**
     * Gibt wieder, ob Drag-and-Drop gerade aktiv und möglich ist.
     */
    private isDnDAllowed;
    noop(): void;
    protected errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    protected notifyFormValueChanged(): void;
    protected updateValidators(validators: ValidatorFnType, checkRequiredValidator: boolean): void;
    protected initFormValueSubscription(): void;
    protected fetchErrorMessage(): string | undefined;
    private updateClearErrorButton;
    onCloseErrorMessage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormFileBase<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFormFileBase<any>, never, never, { "luxUploadReportProgress": { "alias": "luxUploadReportProgress"; "required": false; }; "luxContentsAsBlob": { "alias": "luxContentsAsBlob"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxMaxSizeMB": { "alias": "luxMaxSizeMB"; "required": false; }; "luxMaxFileCount": { "alias": "luxMaxFileCount"; "required": false; }; "luxCapture": { "alias": "luxCapture"; "required": false; }; "luxUploadUrl": { "alias": "luxUploadUrl"; "required": false; }; "luxDnDActive": { "alias": "luxDnDActive"; "required": false; }; "luxMaximumExtended": { "alias": "luxMaximumExtended"; "required": false; }; "luxCustomActionConfigs": { "alias": "luxCustomActionConfigs"; "required": false; }; "luxSelected": { "alias": "luxSelected"; "required": false; }; "luxAccept": { "alias": "luxAccept"; "required": false; }; }, { "luxSelectedChange": "luxSelectedChange"; }, never, never, true, never>;
}

declare class LuxFileInputAcComponent extends LuxFormFileBase<ILuxFileObject | null> implements AfterViewInit {
    visibleInput: ElementRef;
    luxBlur: EventEmitter<FocusEvent>;
    luxFocus: EventEmitter<FocusEvent>;
    luxPlaceholder: string;
    luxClearOnError: boolean;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    focused: boolean;
    _luxUploadActionConfig: ILuxFileActionConfig;
    _luxDeleteActionConfig: ILuxFileActionConfig;
    _luxViewActionConfig: ILuxFileActionConfig;
    _luxDownloadActionConfig: ILuxFileActionConfig;
    get luxUploadActionConfig(): ILuxFileActionConfig;
    set luxUploadActionConfig(config: ILuxFileActionConfig);
    get luxDeleteActionConfig(): ILuxFileActionConfig;
    set luxDeleteActionConfig(config: ILuxFileActionConfig);
    get luxViewActionConfig(): ILuxFileActionConfig;
    set luxViewActionConfig(config: ILuxFileActionConfig);
    get luxDownloadActionConfig(): ILuxFileActionConfig;
    set luxDownloadActionConfig(config: ILuxFileActionConfig);
    ngAfterViewInit(): void;
    onSelectFiles(target: EventTarget | null): void;
    clearFile(): void;
    resetSelected(): void;
    handleViewFileClick(file: ILuxFileObject): void;
    handleDownloadClick(file: ILuxFileObject): void;
    handleUploadClick(files: ILuxFileObject[]): void;
    /**
     * Wird bei der Auswahl von Dateien (Dialog oder DnD) aufgerufen.
     * Aktualisiert die aktuell selektierten Dateien, stößt einen Upload an, handelt Fehlermeldungen und
     * emittet die entsprechenden Events.
     * @param files
     */
    selectFiles(files: FileList | File[]): void;
    onFocus(e: FocusEvent): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    protected errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    protected setFormControlErrors(error: ILuxFileError): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileInputAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileInputAcComponent, "lux-file-input-ac", never, { "luxPlaceholder": { "alias": "luxPlaceholder"; "required": false; }; "luxClearOnError": { "alias": "luxClearOnError"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; "luxUploadActionConfig": { "alias": "luxUploadActionConfig"; "required": false; }; "luxDeleteActionConfig": { "alias": "luxDeleteActionConfig"; "required": false; }; "luxViewActionConfig": { "alias": "luxViewActionConfig"; "required": false; }; "luxDownloadActionConfig": { "alias": "luxDownloadActionConfig"; "required": false; }; }, { "luxBlur": "luxBlur"; "luxFocus": "luxFocus"; }, never, never, true, never>;
}

/**
 * Config-Interface für die Dialoge.
 */
interface ILuxDialogConfig {
    width?: string;
    height?: string;
    minWidth?: string;
    minHeight?: string;
    maxWidth?: string;
    maxHeight?: string;
    panelClass?: string | string[];
    disableClose?: boolean;
}
declare const DEFAULT_DIALOG_CONF: ILuxDialogConfig;

interface ILuxFileListDeleteActionConfig extends ILuxFileListActionConfig {
    isDeletable?: (file: ILuxFileObject) => boolean;
}
interface ILuxFileListActionConfig extends ILuxFileActionConfig {
    hiddenHeader: boolean;
    disabledHeader: boolean;
    iconNameHeader: string;
    labelHeader: string;
}
interface ILuxFilesListActionConfig extends ILuxFilesActionConfig {
    hiddenHeader: boolean;
    disabledHeader: boolean;
    iconNameHeader: string;
    labelHeader: string;
}

/**
 * @deprecated Diese Klasse ist veraltet und sollte nicht mehr verwendet werden.
 * Verwende stattdessen `LuxFileUploadComponent`.
 */
declare class LuxFileListComponent extends LuxFormFileBase<ILuxFileObject[] | null> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private dialogService;
    fileIcons: string[];
    rowWidth: number;
    iconActionBarWidth: number;
    subscriptions: Subscription[];
    fileEntries: QueryList<ElementRef>;
    fileUploadSingleInput: ElementRef;
    fileCard: ElementRef;
    luxShowPreview: boolean;
    luxMultiple: boolean;
    luxHeading: number;
    dialogReplaceConfig: ILuxDialogConfig;
    _luxUploadActionConfig: ILuxFilesListActionConfig;
    _luxDeleteActionConfig: ILuxFileListDeleteActionConfig;
    _luxViewActionConfig: ILuxFileActionConfig;
    _luxDownloadActionConfig: ILuxFileActionConfig;
    get luxUploadActionConfig(): ILuxFilesListActionConfig;
    set luxUploadActionConfig(config: ILuxFilesListActionConfig);
    get luxDeleteActionConfig(): ILuxFileListDeleteActionConfig;
    set luxDeleteActionConfig(config: ILuxFileListDeleteActionConfig);
    get luxViewActionConfig(): ILuxFileActionConfig;
    set luxViewActionConfig(config: ILuxFileActionConfig);
    get luxDownloadActionConfig(): ILuxFileActionConfig;
    set luxDownloadActionConfig(config: ILuxFileActionConfig);
    ngAfterViewInit(): void;
    private updateIconAndImage;
    ngOnDestroy(): void;
    shouldDisplayPreviewImg(index: number): boolean;
    /**
     * Entfernt eine Datei aus den selektierten Dateien.
     * @param index
     */
    removeFile(index: number): void;
    onSelectFiles(target: EventTarget | null): void;
    resetSelected(): void;
    handleViewFileClick(file: ILuxFileObject): void;
    handleDownloadClick(file: ILuxFileObject): void;
    handleUploadClick(files: ILuxFileObject[]): void;
    /**
     * Entfernt die aktuell selektierten Dateien und entfernt etwaige (spezifische) Fehler aus dem FormControl.
     * @param event
     */
    clearFiles(event?: Event): void;
    /**
     * Fügt weitere Dateien zu den bereits vorhandenen hinzu bzw. ersetzt diese.
     * @param files
     */
    selectFiles(files: FileList | File[]): void;
    private updateFilesIntern;
    useArray(): boolean;
    /**
     * Aktualisiert die Preview-Bilder für die (Image-)Dateien.
     *
     * Aktualisierung absichtlich via Funktion und nicht Property-Binding, da potenziell Stack-Size Fehler auftreten,
     * wenn (große) Base64-Strings gegen die src gebunden werden.
     */
    private setImgSrc;
    /**
     * Setzt die Icons für die Elemente in der Auflistung
     */
    private setFileIcons;
    ngAfterViewChecked(): void;
    isArray(object: any): boolean;
    hasOnlyDeleteProtectedFiles(): boolean;
    private resizeIconActionBar;
    protected errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    protected notifyFormValueChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileListComponent, "lux-file-list", never, { "luxShowPreview": { "alias": "luxShowPreview"; "required": false; }; "luxMultiple": { "alias": "luxMultiple"; "required": false; }; "luxHeading": { "alias": "luxHeading"; "required": false; }; "luxUploadActionConfig": { "alias": "luxUploadActionConfig"; "required": false; }; "luxDeleteActionConfig": { "alias": "luxDeleteActionConfig"; "required": false; }; "luxViewActionConfig": { "alias": "luxViewActionConfig"; "required": false; }; "luxDownloadActionConfig": { "alias": "luxDownloadActionConfig"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxFileCaptureDirective {
    protected elementRef: ElementRef<any>;
    protected renderer: Renderer2;
    _luxFileCapture: string;
    get luxFileCapture(): string;
    set luxFileCapture(label: string);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileCaptureDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFileCaptureDirective, "[luxFileCapture]", never, { "luxFileCapture": { "alias": "luxFileCapture"; "required": false; }; }, {}, never, never, true, never>;
}

interface ILuxFileUploadDeleteActionConfig extends ILuxFileActionConfig {
    isDeletable?: (file: ILuxFileObject) => boolean;
}

declare class LuxDialogRef<T = any> {
    _matDialogRef: MatDialogRef<any>;
    _dialogConfirmed: ReplaySubject<void>;
    _dialogDeclined: ReplaySubject<void>;
    _dialogClosed: ReplaySubject<any>;
    _data: any;
    /**
     * Gibt die Component, die in dem Dialog angezeigt wird wieder.
     */
    get componentInstance(): any;
    /**
     * Damit hier ein Wert abgegeben wird, muss "closeDialog" ein Result mit dem Wert "true" übergeben bekommen.
     */
    get dialogConfirmed(): Observable<void>;
    /**
     * Damit hier ein Wert abgegeben wird, muss "closeDialog" ein Result mit dem Wert "false" übergeben bekommen.
     */
    get dialogDeclined(): Observable<void>;
    /**
     * Wird beim Beenden des Dialogs ausgelöst.
     */
    get dialogClosed(): Observable<any>;
    /**
     * Enthält die Daten für die Dialog-Component.
     */
    get data(): T;
    constructor();
    /**
     * (Re-)Initialisiert diese Dialog-Referenz neu.
     * @param matDialogRef
     * @param data
     */
    init(matDialogRef: MatDialogRef<any>, data: any): void;
    /**
     * @deprecated Wird nicht mehr benötigt, da die Dialogreferenz nicht mehr zwischengespeichert wird.
     */
    storeDialogRef(): void;
    /**
     * @deprecated Wird nicht mehr benötigt, da die Dialogreferenz nicht mehr zwischengespeichert wird.
     */
    restoreDialogRef(): void;
    /**
     * Schließt den Dialog und gibt nach Beenden die entsprechenden Events aus.
     * @param result
     */
    closeDialog(result?: any): void;
    private backdropFn;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogRef<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxDialogRef<any>>;
}

declare class LuxFileDeleteDialogComponent {
    luxDialogRef: LuxDialogRef<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileDeleteDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileDeleteDialogComponent, "lux-lux-file-delete-dialog", never, {}, {}, never, never, true, never>;
}

/**
 * Diese Component ist nur eine leichte Ergänzung zu LuxProgress und wird nicht vom Modul exportiert.
 */
declare class LuxFileProgressComponent {
    luxProgress: number;
    luxMode: LuxProgressModeType;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileProgressComponent, "lux-file-progress", never, { "luxProgress": { "alias": "luxProgress"; "required": false; }; "luxMode": { "alias": "luxMode"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxFileRenameDialogComponent implements AfterViewInit {
    luxDialogRef: LuxDialogRef<ILuxFileObject>;
    input: LuxInputAcComponent;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileRenameDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileRenameDialogComponent, "lux-lux-file-rename-dialog", never, {}, {}, never, never, true, never>;
}

declare class LuxFileReplaceDialogComponent {
    luxDialogRef: LuxDialogRef<{
        multiple: boolean;
        deleteProtection: boolean;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileReplaceDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileReplaceDialogComponent, "lux-lux-file-replace-dialog", never, {}, {}, never, never, true, never>;
}

declare class LuxFileUploadComponent extends LuxFormFileBase<ILuxFileObject[] | null> implements OnInit, AfterViewInit, OnDestroy {
    private dialogService;
    private queryService;
    private themeService;
    fileEntries: QueryList<ElementRef>;
    luxLabel: string;
    luxLabelLink: string;
    luxLabelLinkShort: string;
    luxMultiple: boolean;
    luxUploadIcon: string;
    luxDeleteIcon: string;
    luxListOnly: boolean;
    ariaLabelProgress: string;
    theme: string;
    get luxUploadActionConfig(): ILuxFilesActionConfig;
    set luxUploadActionConfig(config: ILuxFilesActionConfig);
    get luxDeleteActionConfig(): ILuxFileUploadDeleteActionConfig;
    set luxDeleteActionConfig(config: ILuxFileUploadDeleteActionConfig);
    get luxViewActionConfig(): ILuxFileActionConfig;
    set luxViewActionConfig(config: ILuxFileActionConfig);
    get luxDownloadActionConfig(): ILuxFileActionConfig;
    set luxDownloadActionConfig(config: ILuxFileActionConfig);
    _luxUploadActionConfig: ILuxFilesActionConfig;
    _luxDeleteActionConfig: ILuxFileUploadDeleteActionConfig;
    _luxViewActionConfig: ILuxFileActionConfig;
    _luxDownloadActionConfig: ILuxFileActionConfig;
    subscriptions: Subscription[];
    fileIcons: string[];
    Math: Math;
    isMobile: boolean;
    dialogDeleteConfig: ILuxDialogConfig;
    dialogReplaceConfig: ILuxDialogConfig;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    useArray(): boolean;
    protected notifyFormValueChanged(): void;
    resetSelected(): void;
    handleViewFileClick(file: ILuxFileObject): void;
    handleDownloadClick(file: ILuxFileObject): void;
    handleUploadClick(files: ILuxFileObject[]): void;
    selectFiles(files: FileList | File[]): void;
    private updateFilesIntern;
    onSelectFiles(target: EventTarget | null): void;
    onUpload(): void;
    onRemoveFile(index: number): void;
    openDeleteDialog(index: number): void;
    /**
     * Setzt die Icons für die Elemente in der Auflistung
     * @param files
     */
    private setFileIcons;
    protected getMaxSizeErrorMessage(file: File): string;
    protected getFileNotAcceptedMessage(file: File): string;
    protected getMultipleForbiddenMessage(): string;
    protected getReadingFileErrorMessage(file: File): string;
    protected getUploadFileErrorMessage(files: File[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFileUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFileUploadComponent, "lux-file-upload", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxLabelLink": { "alias": "luxLabelLink"; "required": false; }; "luxLabelLinkShort": { "alias": "luxLabelLinkShort"; "required": false; }; "luxMultiple": { "alias": "luxMultiple"; "required": false; }; "luxUploadIcon": { "alias": "luxUploadIcon"; "required": false; }; "luxDeleteIcon": { "alias": "luxDeleteIcon"; "required": false; }; "luxListOnly": { "alias": "luxListOnly"; "required": false; }; "luxUploadActionConfig": { "alias": "luxUploadActionConfig"; "required": false; }; "luxDeleteActionConfig": { "alias": "luxDeleteActionConfig"; "required": false; }; "luxViewActionConfig": { "alias": "luxViewActionConfig"; "required": false; }; "luxDownloadActionConfig": { "alias": "luxDownloadActionConfig"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxMaxLengthDirective {
    protected elementRef: ElementRef<any>;
    protected renderer: Renderer2;
    _luxMaxLengthAttr: number;
    get luxMaxLengthAttr(): number;
    set luxMaxLengthAttr(maxLength: number);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMaxLengthDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxMaxLengthDirective, "[luxMaxLengthAttr]", never, { "luxMaxLengthAttr": { "alias": "luxMaxLengthAttr"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxNameDirectiveDirective {
    protected elementRef: ElementRef<any>;
    protected renderer: Renderer2;
    _luxNameAttr?: string | undefined;
    get luxNameAttr(): string | undefined;
    set luxNameAttr(name: string | undefined);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxNameDirectiveDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxNameDirectiveDirective, "[luxNameAttr]", never, { "luxNameAttr": { "alias": "luxNameAttr"; "required": false; }; }, {}, never, never, true, never>;
}

declare type LuxPickValueFnType<O = any, V = any> = ((option: O) => V) | undefined;
declare type LuxCompareWithFnType<O = any> = ((o1: O, o2: O) => boolean) | undefined;
/**
 * Basis-Klasse für FormComponents, die einen ähnlichen Grundaufbau für die Auswahl von
 * Optionen aus einem Array anbieten (Radio-Buttons und Selects z.B.).
 * @param O Optionstyp (z.B Land)
 * @param V Werttyp (z.B. Land, Land[], string, string[],...)
 * @param P PickValueFn-Typ (z.B. string, number,...)
 */
declare abstract class LuxFormSelectableBase<O = any, V = any, P = any> extends LuxFormComponentBase<V> {
    _luxOptions: any[];
    _luxOptionsPickValue: any[];
    _luxPickValue?: LuxPickValueFnType<O, P>;
    _luxCompareWith: (o1: O, o2: O) => boolean;
    luxSelectedChange: EventEmitter<any>;
    luxOptionLabelProp?: string | undefined;
    luxTagId?: string;
    get luxCompareWith(): LuxCompareWithFnType | undefined;
    set luxCompareWith(compareFn: LuxCompareWithFnType | undefined);
    get luxSelected(): V | null;
    set luxSelected(selected: V | null);
    get luxPickValue(): LuxPickValueFnType<O, P>;
    set luxPickValue(pickValueFn: LuxPickValueFnType<O, P>);
    get luxOptions(): any[];
    set luxOptions(options: any[]);
    notifyFormValueChanged(formValue: any): void;
    /**
     * Versucht, wenn Options und FormControl vorhanden sind, den selected-Wert mit den Options
     * zu vergleichen und wenn möglich als luxSelected-Wert zu sichern.
     * @param selected
     */
    private checkSelectedAndUpdate;
    /**
     * Kapselung von der übergebenen luxCompareWith-Funktion.
     * Fängt undefinierte Objekte ab und returned stattdessen false.
     * @param o1
     * @param o2
     */
    compareObjects: (o1: O, o2: O) => boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFormSelectableBase<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFormSelectableBase<any, any, any>, never, never, { "luxOptionLabelProp": { "alias": "luxOptionLabelProp"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxCompareWith": { "alias": "luxCompareWith"; "required": false; }; "luxSelected": { "alias": "luxSelected"; "required": false; }; "luxPickValue": { "alias": "luxPickValue"; "required": false; }; "luxOptions": { "alias": "luxOptions"; "required": false; }; }, { "luxSelectedChange": "luxSelectedChange"; }, never, never, true, never>;
}

declare class LuxRadioAcComponent<O = any, V = any> extends LuxFormSelectableBase<O, V> implements OnDestroy {
    private mediaObserver;
    forceVertical: boolean;
    tempRef?: TemplateRef<any>;
    pb3: boolean;
    luxGroupName: string;
    luxOrientationVertical: boolean;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    focused: boolean;
    private mediaSubscription$;
    constructor();
    get isVertical(): boolean;
    ngOnDestroy(): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    isDisabled(option: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxRadioAcComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxRadioAcComponent<any, any>, "lux-radio-ac", never, { "luxGroupName": { "alias": "luxGroupName"; "required": false; }; "luxOrientationVertical": { "alias": "luxOrientationVertical"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, ["tempRef"], ["lux-form-hint"], true, never>;
}

declare class LuxSelectFilterDirective<T = any> implements OnInit, OnDestroy {
    private readonly matSelect;
    private readonly destroyRef;
    private readonly internalSelect;
    private readonly timers;
    private readonly filterState;
    private readonly focusController;
    private readonly navigator;
    private panelElement?;
    private lastPanelElement?;
    private readonly panelKeydownHandler;
    private readonly documentPointerdownHandler;
    private readonly panelClickHandler;
    luxSelectFilter: boolean;
    luxFilterLabelFn?: (item: T, index: number) => string;
    luxFilterActiveChange: EventEmitter<boolean>;
    filterInputRef?: ElementRef<HTMLInputElement>;
    get filterValue(): string;
    set filterValue(value: string);
    get filteredItems(): Set<T>;
    get filteredIndexes(): Set<number>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    setItems(items: readonly T[]): void;
    onFilterInput(value: string): void;
    setFilterInputRef(ref: ElementRef<HTMLInputElement>): void;
    handleKeydown(event: KeyboardEvent): boolean;
    handleOptionKeydown(event: KeyboardEvent): boolean;
    isItemVisible(item: T): boolean;
    isIndexVisible(index: number): boolean;
    isFilterActive(): boolean;
    private onPanelOpen;
    private onPanelClose;
    private focusFilterInput;
    private setTimer;
    private clearTimer;
    private clearAllTimers;
    private registerPanelKeydownListener;
    private runAfterPanelAttached;
    private removePanelKeydownListener;
    private removeDocumentPointerdownListener;
    private handleKeyboard;
    private restoreTriggerFocusIfNeeded;
    private scheduleManualTabNavigation;
    private getTabNavigationAnchorElement;
    private isEventFromFilterInput;
    private isListNavigationModifierAllowed;
    private handleDocumentPointerdown;
    private handlePanelClick;
    private getSelectHostElement;
    private getFilterHeight;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSelectFilterDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxSelectFilterDirective<any>, "mat-select[luxSelectFilter]", ["luxSelectFilter"], { "luxSelectFilter": { "alias": "luxSelectFilter"; "required": false; }; "luxFilterLabelFn": { "alias": "luxFilterLabelFn"; "required": false; }; }, { "luxFilterActiveChange": "luxFilterActiveChange"; }, never, never, true, never>;
}

/**
 * @param O Optionstyp (z.B Land)
 * @param V Werttyp (z.B. Land, Land[], string, string[],...)
 * @param P PickValueFn-Typ (z.B. string, number,...)
 */
declare class LuxSelectAcComponent<O = any, V = any, P = any> extends LuxFormSelectableBase<O, V, P> implements OnInit, OnChanges {
    private liveAnnouncer;
    tempRef?: TemplateRef<any>;
    matOptions?: QueryList<MatOption>;
    matSelect?: MatSelect;
    /**
     * Platzhalter-Text, der angezeigt wird, wenn kein Wert ausgewählt ist.
     */
    luxPlaceholder: string;
    /**
     * Aktiviert die Mehrfachauswahl (Mehrfachselektion) im Select.
     */
    luxMultiple: boolean;
    /**
     * Aktiviert das Filterfeld im Auswahl-Panel.
     */
    luxEnableFilter: boolean;
    /**
     * Platzhalter-Text, der im Filtereingabefeld angezeigt wird.
     */
    luxFilterPlaceholder: string;
    /**
     * Vorbelegter Filterwert für das Filtereingabefeld.
     */
    luxFilterValue: string;
    /**
     * ARIA-Label für die Schaltfläche zum Löschen des Filterwertes.
     */
    luxFilterClearAriaLabel: string;
    /**
     * Begrenzt die Anzahl der gleichzeitig sichtbaren Optionen im geöffneten Panel.
     * Werte <= 0 deaktivieren das Override und verwenden die Standardhöhe.
     */
    luxVisibleOptionCount?: number | null;
    /**
     * Blendet alle Standard-Labels des Formularfeldes aus.
     */
    luxNoLabels: boolean;
    /**
     * Blendet das obere Label (z. B. Feldbezeichnung) aus.
     */
    luxNoTopLabel: boolean;
    /**
     * Blendet das untere Label (z. B. Fehlermeldungen/Hinweise) aus.
     */
    luxNoBottomLabel: boolean;
    displayedViewValue?: string;
    focused: boolean;
    /**
     * Indizes in der Reihenfolge, wie die Optionen gerendert werden sollen.
     * Selektierte Optionen werden nach oben sortiert.
     */
    renderOptionIndexes: number[];
    /**
     * Label-Extractor für Filter-Directive.
     * Wird als Arrow-Function definiert um this-Kontext zu erhalten.
     */
    filterLabelFn: (option: O, _index: number) => string;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    notifyFormValueChanged(formValue: any): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    /**
     * Wird aufgerufen, wenn das Panel geöffnet/geschlossen wird.
     * Übergibt Items an die Filter-Directive und sortiert Optionen.
     */
    onOpenedChange(open: boolean, filterDirective?: LuxSelectFilterDirective): void;
    describedBy(): string | undefined;
    /**
     * Wrapper-Klick: Fokus setzen und Panel öffnen (falls erlaubt).
     * Verwendet mousedown statt click, um Event-Bubbling nicht zu stören.
     */
    onWrapperClick(event: MouseEvent): void;
    /**
     * Sortiert die Optionen: selektierte zuerst, dann rest.
     * Wird beim Öffnen des Panels aufgerufen.
     */
    private refreshRenderOptionIndexes;
    /**
     * Prüft, ob eine Option selektiert ist.
     */
    private isOptionSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSelectAcComponent<any, any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSelectAcComponent<any, any, any>, "lux-select-ac", never, { "luxPlaceholder": { "alias": "luxPlaceholder"; "required": false; }; "luxMultiple": { "alias": "luxMultiple"; "required": false; }; "luxEnableFilter": { "alias": "luxEnableFilter"; "required": false; }; "luxFilterPlaceholder": { "alias": "luxFilterPlaceholder"; "required": false; }; "luxFilterValue": { "alias": "luxFilterValue"; "required": false; }; "luxFilterClearAriaLabel": { "alias": "luxFilterClearAriaLabel"; "required": false; }; "luxVisibleOptionCount": { "alias": "luxVisibleOptionCount"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, ["tempRef"], never, true, never>;
}

declare type LuxDisplayWithAcFnType = (value: number) => string;
declare type LuxSliderAcTickInterval = 'auto' | number;
declare type LuxSliderAcColor = 'primary' | 'accent' | 'warn';
declare class LuxSliderAcComponent extends LuxFormComponentBase<number> implements OnInit, OnChanges, OnDestroy {
    matSlider?: MatSlider;
    luxChange: EventEmitter<number>;
    luxInput: EventEmitter<number>;
    luxValueChange: EventEmitter<number>;
    luxValuePercent: EventEmitter<number>;
    luxColor: LuxSliderAcColor;
    luxShowThumbLabel: boolean;
    luxTagId?: string;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    get luxValue(): number;
    set luxValue(value: number);
    _luxMax: number;
    _luxRequired: boolean;
    _luxMin: number;
    _luxStep: number;
    _luxDisplayWith: LuxDisplayWithAcFnType;
    subscription?: Subscription;
    get luxDisplayWith(): LuxDisplayWithAcFnType | undefined;
    set luxDisplayWith(displayFn: LuxDisplayWithAcFnType | undefined);
    get luxMax(): number;
    set luxMax(value: number);
    get luxMin(): number;
    set luxMin(value: number);
    get luxStep(): number;
    set luxStep(value: number);
    get luxRequired(): boolean;
    set luxRequired(value: boolean);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    /**
     * Wird beim Ändern des Slider-Wertes aufgerufen.
     * @param value
     */
    onChange(value: number): void;
    /**
     * Wird beim Bewegen des Sliders aufgerufen.
     * @param value
     */
    onInput(value: number): void;
    descripedBy(): string | undefined;
    notifyFormValueChanged(formValue: any): void;
    /**
     * Workaround, ohne den der Slider leider nicht beim Wechsel zum disabled-State den Gab
     * um den Thumb herum zeichnet.
     */
    private redrawSliderWorkaround;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSliderAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSliderAcComponent, "lux-slider-ac", never, { "luxColor": { "alias": "luxColor"; "required": false; }; "luxShowThumbLabel": { "alias": "luxShowThumbLabel"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; "luxValue": { "alias": "luxValue"; "required": false; }; "luxDisplayWith": { "alias": "luxDisplayWith"; "required": false; }; "luxMax": { "alias": "luxMax"; "required": false; }; "luxMin": { "alias": "luxMin"; "required": false; }; "luxStep": { "alias": "luxStep"; "required": false; }; "luxRequired": { "alias": "luxRequired"; "required": false; }; }, { "luxChange": "luxChange"; "luxInput": "luxInput"; "luxValueChange": "luxValueChange"; "luxValuePercent": "luxValuePercent"; }, never, never, true, never>;
}

declare class LuxTextareaAcComponent<T = string> extends LuxFormInputBaseClass<T> implements OnInit {
    private liveAnnouncer;
    luxMaxRows: number;
    luxMinRows: number;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    luxHideCounterLabel: boolean;
    set luxMaxLength(maxLength: number);
    get luxMaxLength(): number;
    focused: boolean;
    counterLabel: string;
    _luxMaxLength: number;
    ngOnInit(): void;
    notifyFormValueChanged(formValue: any): void;
    onFocus(e: FocusEvent): void;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    private updateCounterLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTextareaAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTextareaAcComponent<any>, "lux-textarea-ac", never, { "luxMaxRows": { "alias": "luxMaxRows"; "required": false; }; "luxMinRows": { "alias": "luxMinRows"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; "luxHideCounterLabel": { "alias": "luxHideCounterLabel"; "required": false; }; "luxMaxLength": { "alias": "luxMaxLength"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxToggleAcComponent<T = boolean> extends LuxFormCheckableBaseClass<T> implements OnInit {
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    focused: boolean;
    onFocusIn(e: FocusEvent): void;
    onFocusOut(e: FocusEvent): void;
    descripedBy(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxToggleAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxToggleAcComponent<any>, "lux-toggle-ac", never, { "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxFilter {
    id?: string;
    name: string;
    data: any;
}

declare class LuxFilterItem<T = any> {
    static DEFAULT_VALUES: (string | boolean | null | undefined)[];
    label: string;
    binding: string;
    component: LuxFormComponentBase<T>;
    defaultValues: any[];
    value: T;
    color: LuxThemePalette;
    disabled: boolean;
    hidden: boolean;
    multiValueIndex: number;
    renderFn: (filter: LuxFilterItem<T>, value: T) => string;
    constructor(label: string, binding: string, component: LuxFormComponentBase<T>);
}

declare class LuxLookupHandlerService {
    private lookupElements;
    constructor();
    /**
     * Fügt ein LookupComponent zu der Map hinzu.
     * @param string name
     * @param name
     */
    addLookupElement(name: string): void;
    /**
     * Gibt das Subject einer LookupComponent als Observable zurück (oder null).
     * @param string name
     * @param name
     * @returns Observable<any> | null
     */
    getLookupElementObsv(name: string): Observable<any> | null;
    /**
     * Gibt das Subject einer LookupComponent zurück (oder null).
     * @param string name
     * @param name
     * @returns Observable<any> | null
     */
    getLookupElementSubject(name: string): Subject<void> | null;
    /**
     * Stößt das Neuladen von Schlüsseltabellendaten einer LookupComponent an.
     * @param string name
     * @param lookupId
     */
    reloadData(lookupId: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLookupHandlerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxLookupHandlerService>;
}

/**
 * Enums, welche die auswaehlbaren Felder fuer den Response einer Lookup-Service-Abfrage beinhaltet.
 */
declare enum LuxFieldValues {
    kurz = "kurz",
    lang1 = "lang1",
    lang2 = "lang2",
    gueltig_von = "gueltig_von",
    gueltig_bis = "gueltig_bis",
    ableitungsText1 = "ableitungsText1",
    ableitungsText2 = "ableitungsText2",
    ableitungsText3 = "ableitungsText3",
    ableitungsText4 = "ableitungsText4",
    ableitungsText5 = "ableitungsText5",
    ableitungsText6 = "ableitungsText6"
}
declare enum LuxBehandlungsOptionenUngueltige {
    anzeigen = "anzeigen",
    ausgrauen = "ausgrauen",
    ausblenden = "ausblenden"
}
/**
 * Class, welche benutzt wird um die Abfrage an den Lookup-Service zu modifizeren.
 */
declare class LuxLookupParameters {
    knr: number;
    keys: any[];
    fields: LuxFieldValues[];
    raw: boolean;
    constructor(data: {
        knr: number;
        keys?: string[];
        fields?: LuxFieldValues[];
        raw?: boolean;
    });
}

/**
 * Kennzeichnet einen einzelnen Eintrag in einer Schlüsseltabelle.
 */
declare class LuxLookupTableEntry {
    gueltigkeitBis?: string;
    gueltigkeitVon?: string;
    key: string;
    kurzText?: string;
    langText1?: string;
    langText2?: string;
    ableitungsText1?: string;
    ableitungsText2?: string;
    ableitungsText3?: string;
    ableitungsText4?: string;
    ableitungsText5?: string;
    ableitungsText6?: string;
    isUngueltig?: boolean;
    constructor(partial: Partial<LuxLookupTableEntry>);
}

declare class LuxLookupService {
    private http;
    /**
     * Liefert die Eintraege einer Schluesseltabelle.
     * @param tableNo
     * @param parameters
     * @param url
     * @returns Observable<LuxLookupTableEntry[]>
     */
    getLookupTable(tableNo: string, parameters: LuxLookupParameters, url: string): Observable<LuxLookupTableEntry[]>;
    /**
     * Generiert die Standard-Parameter fuer einen Lookup-Request.
     * @param parameters
     * @returns HttpParams
     */
    generateParameters(parameters: LuxLookupParameters): HttpParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLookupService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxLookupService>;
}

/**
 * Der Typ für die Lookup-Vergleichsfunktionen.
 */
type LuxLookupCompareFn<T = LuxLookupTableEntry> = (a: T, b: T) => number;
/**
 * Diese Vergleichsfunktion sortiert die Schlüsseltabelleneinträge nach ihrem Schlüssel.
 * @param a Erster Schlüsseltabelleneintrag.
 * @param b Zweiter Schlüsseltabelleneintrag.
 */
declare const luxLookupCompareKeyFn: LuxLookupCompareFn;
/**
 * Diese Vergleichsfunktion sortiert die Schlüsseltabelleneinträge nach ihrem Kurztext.
 * @param a Erster Schlüsseltabelleneintrag.
 * @param b Zweiter Schlüsseltabelleneintrag.
 */
declare const luxLookupCompareKurzTextFn: LuxLookupCompareFn;
/**
 * Diese Vergleichsfunktion sortiert die Schlüsseltabelleneinträge nach ihrem Langtext1.
 * @param a Erster Schlüsseltabelleneintrag.
 * @param b Zweiter Schlüsseltabelleneintrag.
 */
declare const luxLookupCompareLangText1Fn: LuxLookupCompareFn;
/**
 * Diese Vergleichsfunktion sortiert die Schlüsseltabelleneinträge nach ihrem Langtext2.
 * @param a Erster Schlüsseltabelleneintrag.
 * @param b Zweiter Schlüsseltabelleneintrag.
 */
declare const luxLookupCompareLangText2Fn: LuxLookupCompareFn;
declare abstract class LuxLookupComponent<T> extends LuxFormComponentBase<T> implements OnInit, OnDestroy {
    LuxBehandlungsOptionenUngueltige: typeof LuxBehandlungsOptionenUngueltige;
    protected lookupService: LuxLookupService;
    protected lookupHandler: LuxLookupHandlerService;
    entries: LuxLookupTableEntry[];
    apiPath: string;
    luxPlaceholder: string;
    luxLookupId: string;
    luxTableNo: string;
    luxRenderProp: any;
    luxRenderPropNoPropertyLabel: string;
    luxBehandlungUngueltige: LuxBehandlungsOptionenUngueltige;
    luxParameters?: LuxLookupParameters;
    luxCustomStyles?: object | null;
    luxCustomInvalidStyles?: object | null;
    luxCompareFn?: LuxLookupCompareFn;
    luxTagId?: string;
    luxDataLoaded: EventEmitter<boolean>;
    luxDataLoadedAsArray: EventEmitter<T[]>;
    luxValueChange: EventEmitter<T>;
    subscriptions: Subscription[];
    get luxValue(): T;
    set luxValue(value: T);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Gibt zurueck, ob die RenderProperty eine Funktion ist oder nicht.
     * @returns boolean
     */
    isRenderPropAFunction(): boolean;
    /**
     * Gibt zurück ob sich das entsprechende Element in der Liste ungültiger Elemente befindet.
     * @param LuxLookupTableEntry entry
     * @param entry
     * @returns boolean
     */
    isUngueltig(entry: LuxLookupTableEntry): boolean;
    /**
     * Gibt zurück ob ungültige Einträge angezeigt werden sollen.
     * @returns boolean
     */
    showUngueltige(): boolean;
    /**
     * Gibt zurück ob ungültige Einträge deaktiviert werden sollen.
     * @returns boolean
     */
    disableUngueltige(): boolean;
    /**
     * Gibt die mitgegebenen Styles abhaengig ob das Element invalid ist zurueck.
     * @param boolean invalid
     * @param invalid
     * @returns LuxLookupOptionStyle
     */
    getStyles(invalid: boolean | undefined): object;
    /**
     * @override
     * @param value
     * @param errors
     */
    errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    getLabel(entry: any): string;
    /**
     * Holt die Lookup-Table Daten vom Backend
     */
    protected fetchLookupData(): void;
    /**
     * Setzt die aktuellen Werte auf die mitgegebenen Entries.
     * @param entries
     */
    protected setLookupData(entries: LuxLookupTableEntry[]): void;
    notifyFormValueChanged(formValue: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLookupComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxLookupComponent<any>, never, never, { "luxPlaceholder": { "alias": "luxPlaceholder"; "required": false; }; "luxLookupId": { "alias": "luxLookupId"; "required": false; }; "luxTableNo": { "alias": "luxTableNo"; "required": false; }; "luxRenderProp": { "alias": "luxRenderProp"; "required": false; }; "luxRenderPropNoPropertyLabel": { "alias": "luxRenderPropNoPropertyLabel"; "required": false; }; "luxBehandlungUngueltige": { "alias": "luxBehandlungUngueltige"; "required": false; }; "luxParameters": { "alias": "luxParameters"; "required": false; }; "luxCustomStyles": { "alias": "luxCustomStyles"; "required": false; }; "luxCustomInvalidStyles": { "alias": "luxCustomInvalidStyles"; "required": false; }; "luxCompareFn": { "alias": "luxCompareFn"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxValue": { "alias": "luxValue"; "required": false; }; }, { "luxDataLoaded": "luxDataLoaded"; "luxDataLoadedAsArray": "luxDataLoadedAsArray"; "luxValueChange": "luxValueChange"; }, never, never, true, never>;
}

declare class LuxLookupErrorStateMatcher implements ErrorStateMatcher {
    lookupComponent: LuxLookupComponent<any>;
    constructor(lookupComponent: LuxLookupComponent<any>);
    isErrorState(control: FormControl | UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
}

declare class LuxLookupAutocompleteAcComponent<T = LuxLookupTableEntry | null> extends LuxLookupComponent<T> implements OnInit, AfterViewInit {
    filtered: LuxLookupTableEntry[];
    entriesCount: number;
    latestSearchValue?: string;
    stateMatcher: LuxLookupErrorStateMatcher;
    luxDebounceTime: number;
    luxMaximumDisplayed: number;
    luxNoLabels: boolean;
    luxNoTopLabel: boolean;
    luxNoBottomLabel: boolean;
    luxBlur: EventEmitter<FocusEvent>;
    luxFocus: EventEmitter<FocusEvent>;
    matInput: ElementRef;
    matAutocomplete?: MatAutocomplete;
    matAutocompleteTrigger?: MatAutocompleteTrigger;
    constructor();
    ngAfterViewInit(): void;
    ngOnInit(): void;
    protected setLookupData(entries: LuxLookupTableEntry[]): void;
    /**
     * Vergleicht den eingegebenen Wert mit den Display-Werten der Einträge.
     * @param filterTerm
     * @returns LuxLookupTableEntry[]
     */
    filter(filterTerm: any): LuxLookupTableEntry[];
    /**
     * Bestimmt wie eingegebene Optionen dargestellt werden.
     * @param option
     * @returns string
     */
    displayFn(option: LuxLookupTableEntry | string): string;
    /**
     * Wird beim Klick auf das Input Feld aufgerufen.
     * @param clickEvent
     */
    onClick(clickEvent: any): void;
    /**
     * Wrapper-Klick: Fokus setzen und Panel öffnen (falls erlaubt).
     * Verwendet mousedown statt click, um Event-Bubbling nicht zu stören.
     */
    onWrapperClick(event: MouseEvent): void;
    /**
     * Setzt den aktuellen Value-Wert auf den ausgewählten Wert.
     * @param MatAutocompleteSelectedEvent event
     * @param event
     */
    selected(event: MatAutocompleteSelectedEvent): void;
    /**
     * @override
     * @param value
     * @param errors
     */
    errorMessageModifier(value: any, errors: LuxValidationErrors): string | undefined;
    private findFilteredOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLookupAutocompleteAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLookupAutocompleteAcComponent<any>, "lux-lookup-autocomplete-ac", never, { "luxDebounceTime": { "alias": "luxDebounceTime"; "required": false; }; "luxMaximumDisplayed": { "alias": "luxMaximumDisplayed"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, { "luxBlur": "luxBlur"; "luxFocus": "luxFocus"; }, never, never, true, never>;
}

declare class LuxLookupComboboxAcComponent<T = LuxLookupTableEntry> extends LuxLookupComponent<T> implements AfterViewInit, OnDestroy {
    /**
     * Wenn es weniger oder gleich viele selektierte Einträge sind, wird der höchste Index ermittelt und alle Optionen bis dahin geladen.
     * Wenn es mehr sind, werden alle Optionen nachgeladen, um Performance-Probleme beim Ermitteln des höchsten Index zu vermeiden.
     */
    private static readonly SELECTED_ENTRIES_THRESHOLD;
    /**
     * Aktiviert die Mehrfachauswahl (Mehrfachselektion) in der Combobox.
     */
    luxMultiple: boolean;
    /**
     * Größe des Nachlade-Blocks für die angezeigten Einträge.
     *
     * Beim Öffnen werden initial nur so viele Einträge gerendert. Sobald der User im Panel scrollt,
     * werden weitere Einträge in Blöcken dieser Größe nachgeladen.
     */
    luxEntryBlockSize: number;
    /**
     * Begrenzt die Anzahl der gleichzeitig sichtbaren Optionen im geöffneten Panel.
     * Werte <= 0 deaktivieren das Override und verwenden die Standardhöhe.
     */
    luxVisibleOptionCount?: number | null;
    /**
     * Steuert, ob ein zusätzlicher Leereintrag ("keine Auswahl") angeboten wird.
     *
     * Der Leereintrag wird nur im Single-Select angezeigt (also wenn {@link luxMultiple} = false).
     */
    luxWithEmptyEntry: boolean;
    /**
     * Blendet ein Filterfeld im Auswahl-Panel ein und aktiviert die clientseitige Filterung
     * in den aktuell geladenen Einträgen.
     */
    luxEnableFilter: boolean;
    /**
     * Platzhalter-Text des Filtereingabefeldes im Panel.
     *
     * Wird zusätzlich als ARIA-Label am nativen Input gesetzt.
     */
    luxFilterPlaceholder: string;
    /**
     * Aktueller Textwert des Filterfeldes.
     */
    luxFilterValue: string;
    /**
     * ARIA-Label für die Schaltfläche zum Löschen des Filterwertes.
     */
    luxFilterClearAriaLabel: string;
    /**
     * Blendet alle Standard-Labels des Formularfeldes aus.
     */
    luxNoLabels: boolean;
    /**
     * Blendet das obere Label (z.B. Feldbezeichnung) aus.
     */
    luxNoTopLabel: boolean;
    /**
     * Blendet das untere Label (z.B. Fehlermeldungen/Hinweise) aus.
     */
    luxNoBottomLabel: boolean;
    matSelect: MatSelect;
    filterDirective?: LuxSelectFilterDirective;
    stateMatcher: LuxLookupErrorStateMatcher;
    displayedEntries: LuxLookupTableEntry[];
    invisibleEntries: LuxLookupTableEntry[];
    /**
     * Einträge in der Render-Reihenfolge: selektierte zuerst, dann rest.
     */
    renderedEntries: LuxLookupTableEntry[];
    subscription?: Subscription;
    private panelScrollHandler?;
    private panelElement?;
    /**
     * Label-Extractor für Filter-Directive.
     * Wird als Arrow-Function definiert um this-Kontext zu erhalten.
     */
    filterLabelFn: (entry: LuxLookupTableEntry, _index: number) => string;
    constructor();
    notifyFormValueChanged(formValue: any): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Vergleicht die Optionen anhand der Key-Werte
     * @param value1
     * @param value2
     * @returns boolean
     */
    compareByKey(value1: LuxLookupTableEntry, value2: LuxLookupTableEntry): boolean;
    setLookupData(entries: LuxLookupTableEntry[]): void;
    /**
     * Setzt den aktuellen Value-Wert auf den ausgewählten Wert.
     * @param selectChange
     */
    selected(selectChange: MatSelectChange): void;
    /**
     * Wird aufgerufen, wenn sich der Filter-Aktiv-Status ändert.
     * Lädt bei aktivem Filter alle invisibleEntries nach.
     */
    onFilterActiveChange(isActive: boolean): void;
    /**
     * Fügt beim öffnen des Selects einen Scroll-Listener hinzu.
     * @param panelElement
     */
    private registerPanelScrollEvent;
    private removePanelScrollEvent;
    private loadOnScroll;
    /**
     * Lädt den nächsten Block Daten aus den Entries nach.
     */
    updateDisplayedEntries(blockSize?: number): void;
    /**
     * Stellt sicher, dass die selektierten Eintr�ge in displayedEntries geladen sind.
     * Wenn nicht, werden sie nachgeladen.
     */
    ensureSelectedEntriesLoaded(): void;
    /**
     * Wrapper-Klick: Fokus setzen und Panel öffnen (falls erlaubt).
     * Verwendet mousedown statt click, um Event-Bubbling nicht zu stören.
     */
    onWrapperClick(event: MouseEvent): void;
    private ensureSingleSelectedEntryLoaded;
    private ensureMultipleSelectedEntriesLoaded;
    /**
     * Sortiert die Einträge: selektierte zuerst, dann rest.
     * Wird beim Öffnen des Panels aufgerufen.
     */
    private refreshRenderedEntries;
    /**
     * Prüft, ob ein Eintrag selektiert ist.
     */
    private isEntrySelected;
    private shouldLoadAllEntriesForActiveFilter;
    private ensureInitialFilterEntriesLoaded;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLookupComboboxAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLookupComboboxAcComponent<any>, "lux-lookup-combobox-ac", never, { "luxMultiple": { "alias": "luxMultiple"; "required": false; }; "luxEntryBlockSize": { "alias": "luxEntryBlockSize"; "required": false; }; "luxVisibleOptionCount": { "alias": "luxVisibleOptionCount"; "required": false; }; "luxWithEmptyEntry": { "alias": "luxWithEmptyEntry"; "required": false; }; "luxEnableFilter": { "alias": "luxEnableFilter"; "required": false; }; "luxFilterPlaceholder": { "alias": "luxFilterPlaceholder"; "required": false; }; "luxFilterValue": { "alias": "luxFilterValue"; "required": false; }; "luxFilterClearAriaLabel": { "alias": "luxFilterClearAriaLabel"; "required": false; }; "luxNoLabels": { "alias": "luxNoLabels"; "required": false; }; "luxNoTopLabel": { "alias": "luxNoTopLabel"; "required": false; }; "luxNoBottomLabel": { "alias": "luxNoBottomLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare type LuxFilterRenderFnType<T = any> = (filter: LuxFilterItem<T>, value: T) => string;
declare class LuxFilterItemDirective implements OnInit, OnChanges {
    inputAuthentic: LuxInputAcComponent<any> | null;
    autoCompleteAuthentic: LuxAutocompleteAcComponent<any, any> | null;
    autoCompleteLookupAuthentic: LuxLookupAutocompleteAcComponent<any> | null;
    datepickerAuthentic: LuxDatepickerAcComponent<any> | null;
    datetimepickerAuthentic: LuxDatetimepickerAcComponent<any> | null;
    toggleAuthentic: LuxToggleAcComponent<any> | null;
    checkboxAuthentic: LuxCheckboxAcComponent<any> | null;
    selectAuthentic: LuxSelectAcComponent<any, any, any> | null;
    selectLookupAuthentic: LuxLookupComboboxAcComponent<any> | null;
    radioAuthentic: LuxRadioAcComponent<any, any> | null;
    private elRef;
    private renderer;
    formComponent: LuxFormComponentBase;
    filterItem: LuxFilterItem<any>;
    luxFilterLabel: string;
    luxFilterColor: LuxThemePalette;
    luxFilterDefaultValues: (string | boolean | null | undefined)[];
    luxFilterRenderFn?: LuxFilterRenderFnType;
    luxFilterHidden: boolean;
    luxFilterDisabled: boolean;
    constructor();
    ngOnInit(): void;
    private updateHiddenState;
    private updateDisabledState;
    ngOnChanges(changes: SimpleChanges): void;
    renderLabelFn<T>(filterItem: LuxFilterItem<T>, value: T): any;
    renderDateFn<T>(filterItem: LuxFilterItem<T>): any;
    renderDateAcFn(filterItem: LuxFilterItem, value: any): any;
    renderDateTimeFn<T>(filterItem: LuxFilterItem<T>): any;
    renderDateTimeAcFn(filterItem: LuxFilterItem, value: any): any;
    renderToggleFn<T>(filterItem: LuxFilterItem<T>, value: any): "an" | "aus";
    renderIdentityFn<T>(filterItem: LuxFilterItem<T>, value: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFilterItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxFilterItemDirective, "[luxFilterItem]", never, { "luxFilterLabel": { "alias": "luxFilterLabel"; "required": false; }; "luxFilterColor": { "alias": "luxFilterColor"; "required": false; }; "luxFilterDefaultValues": { "alias": "luxFilterDefaultValues"; "required": false; }; "luxFilterRenderFn": { "alias": "luxFilterRenderFn"; "required": false; }; "luxFilterHidden": { "alias": "luxFilterHidden"; "required": false; }; "luxFilterDisabled": { "alias": "luxFilterDisabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxFilterFormExtendedComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFilterFormExtendedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFilterFormExtendedComponent, "lux-filter-form-extended", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxFilterFormComponent implements OnInit, AfterViewInit, OnDestroy {
    private dialogService;
    private cdr;
    private mediaQuery;
    dialogConfig: ILuxDialogConfig;
    formElementes: LuxFilterItemDirective[];
    formElementesQL: QueryList<LuxFilterItemDirective>;
    extendedOptions?: LuxFilterFormExtendedComponent;
    _luxFilterValues: {};
    _luxFilterExpanded: boolean;
    luxTitle: string;
    luxButtonRaised: boolean;
    luxButtonFlat: boolean;
    luxButtonFilterLabel: string;
    luxButtonFilterColor: LuxThemePalette;
    luxButtonResetLabel: string;
    luxButtonResetColor?: LuxThemePalette;
    luxButtonSaveLabel: string;
    luxButtonSaveColor?: LuxThemePalette;
    luxButtonLoadLabel: string;
    luxButtonLoadColor?: LuxThemePalette;
    luxButtonDialogSave: LuxThemePalette;
    luxButtonDialogLoad: LuxThemePalette;
    luxButtonDialogDelete: LuxThemePalette;
    luxButtonDialogCancel?: LuxThemePalette;
    luxButtonDialogClose?: LuxThemePalette;
    luxDefaultFilterMessage: string;
    luxShowChips: boolean;
    luxHideChipsBorder: boolean;
    luxHideMenu: boolean;
    luxStoredFilters: LuxFilter[];
    luxDisableShortcut: boolean;
    luxShowAsCard: boolean;
    set luxExpandedLabelOpen(label: string);
    get luxExpandedLabelOpen(): string;
    _luxExpandedLabelOpen: string;
    set luxExpandedLabelClose(label: string);
    get luxExpandedLabelClose(): string;
    _luxExpandedLabelClose: string;
    get luxFilterExpanded(): boolean;
    set luxFilterExpanded(expanded: boolean);
    get luxFilterValues(): any;
    set luxFilterValues(filter: any);
    luxOnFilter: EventEmitter<string>;
    luxOnSave: EventEmitter<LuxFilter>;
    luxOnLoad: EventEmitter<string>;
    luxOnDelete: EventEmitter<LuxFilter>;
    luxOnReset: EventEmitter<void>;
    luxFilterExpandedChange: EventEmitter<boolean>;
    filterForm: FormGroup;
    subscriptions: Subscription[];
    filterItems: LuxFilterItem<any>[];
    hasSaveAction: boolean;
    hasLoadAction: boolean;
    initComplete: boolean;
    initFilterValue: null;
    isMobile: boolean;
    constructor();
    ngOnInit(): void;
    private updateFilterChips;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    openSaveDialog(): void;
    openLoadDialog(): void;
    onDelete(filter: LuxFilter): void;
    onSave(filterName: string): void;
    onLoad(filtername: string): void;
    onReset(): void;
    filterChipRemoved(indexRemoved: number): void;
    onShiftEnter(): void;
    onFilter(): void;
    onFilterIntern(changeExpandState: boolean): void;
    registerFilterItems(filterItemDirectives: LuxFilterItemDirective[]): void;
    private createFilterObject;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFilterFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFilterFormComponent, "lux-filter-form", never, { "luxTitle": { "alias": "luxTitle"; "required": false; }; "luxButtonRaised": { "alias": "luxButtonRaised"; "required": false; }; "luxButtonFlat": { "alias": "luxButtonFlat"; "required": false; }; "luxButtonFilterLabel": { "alias": "luxButtonFilterLabel"; "required": false; }; "luxButtonFilterColor": { "alias": "luxButtonFilterColor"; "required": false; }; "luxButtonResetLabel": { "alias": "luxButtonResetLabel"; "required": false; }; "luxButtonResetColor": { "alias": "luxButtonResetColor"; "required": false; }; "luxButtonSaveLabel": { "alias": "luxButtonSaveLabel"; "required": false; }; "luxButtonSaveColor": { "alias": "luxButtonSaveColor"; "required": false; }; "luxButtonLoadLabel": { "alias": "luxButtonLoadLabel"; "required": false; }; "luxButtonLoadColor": { "alias": "luxButtonLoadColor"; "required": false; }; "luxButtonDialogSave": { "alias": "luxButtonDialogSave"; "required": false; }; "luxButtonDialogLoad": { "alias": "luxButtonDialogLoad"; "required": false; }; "luxButtonDialogDelete": { "alias": "luxButtonDialogDelete"; "required": false; }; "luxButtonDialogCancel": { "alias": "luxButtonDialogCancel"; "required": false; }; "luxButtonDialogClose": { "alias": "luxButtonDialogClose"; "required": false; }; "luxDefaultFilterMessage": { "alias": "luxDefaultFilterMessage"; "required": false; }; "luxShowChips": { "alias": "luxShowChips"; "required": false; }; "luxHideChipsBorder": { "alias": "luxHideChipsBorder"; "required": false; }; "luxHideMenu": { "alias": "luxHideMenu"; "required": false; }; "luxStoredFilters": { "alias": "luxStoredFilters"; "required": false; }; "luxDisableShortcut": { "alias": "luxDisableShortcut"; "required": false; }; "luxShowAsCard": { "alias": "luxShowAsCard"; "required": false; }; "luxExpandedLabelOpen": { "alias": "luxExpandedLabelOpen"; "required": false; }; "luxExpandedLabelClose": { "alias": "luxExpandedLabelClose"; "required": false; }; "luxFilterExpanded": { "alias": "luxFilterExpanded"; "required": false; }; "luxFilterValues": { "alias": "luxFilterValues"; "required": false; }; }, { "luxOnFilter": "luxOnFilter"; "luxOnSave": "luxOnSave"; "luxOnLoad": "luxOnLoad"; "luxOnDelete": "luxOnDelete"; "luxOnReset": "luxOnReset"; "luxFilterExpandedChange": "luxFilterExpandedChange"; }, ["extendedOptions", "formElementesQL"], ["lux-filter-form-extended", "*"], true, never>;
}

declare class LuxFilterLoadDialogComponent implements OnInit {
    luxDialogRef: LuxDialogRef<LuxFilterFormComponent>;
    filterArr: LuxFilter[];
    component: LuxFilterFormComponent;
    ngOnInit(): void;
    onDelete(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFilterLoadDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFilterLoadDialogComponent, "lux-filter-load-dialog", never, {}, {}, never, never, true, never>;
}

declare class LuxFilterSaveDialogComponent implements OnInit, AfterViewInit {
    luxDialogRef: LuxDialogRef<LuxFilterFormComponent>;
    filterNameComponent: LuxInputAcComponent;
    currentFilters: LuxFilter[];
    filterName: string;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onSave(): void;
    validateForbiddenName(): ValidatorFn;
    filterErrorCallback: (value: any, errors: LuxValidationErrors) => "Der Name existiert bereits." | "Pflichtfeld" | "Es ist ein Fehler aufgetreten.";
    private checkIfFilterNameExists;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxFilterSaveDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxFilterSaveDialogComponent, "lux-filter-save-dialog", never, {}, {}, never, never, true, never>;
}

declare enum LuxConsentPurpose {
    Essential = "essential",
    Preferences = "preferences",
    Statistics = "statistics",
    Marketing = "marketing",
    Other = "other"
}
declare enum LuxConsentStorageType {
    Cookie = "Cookie",
    LocalStorage = "Local Storage",
    SessionStorage = "Session Storage"
}
interface LuxConsentEntry {
    type: LuxConsentStorageType;
    name: string;
    /** Wenn true, gilt der `name` als Prefix für dynamische Keys (z. B. "[lux-tour-hint-dsa]") */
    nameIsPrefix?: boolean;
    processingCountry: string;
    purpose: LuxConsentPurpose;
    duration: string;
    description: string;
}
interface LuxConsentState {
    purposes: LuxConsentPurpose[];
    timestamp: string;
}
interface LuxCookieCategory {
    purpose: LuxConsentPurpose;
    name: string;
    enabled: boolean;
    disabled: boolean;
    hint: string;
}

interface ILuxConsentConfig {
    cookieKey: string;
    consentCookieDurationDays?: number;
    /** Optional additional entries provided by the host app; merged with defaults by the service. */
    entries?: LuxConsentEntry[];
    impressumUrl?: string;
    impressumComponent?: Type<unknown>;
    impressumComponentLoader?: () => Promise<Type<unknown>>;
    impressumComponentInputs?: Record<string, unknown>;
    datenschutzUrl?: string;
    datenschutzComponent?: Type<unknown>;
    datenschutzComponentLoader?: () => Promise<Type<unknown>>;
    datenschutzComponentInputs?: Record<string, unknown>;
}

interface ILuxConsentDialogLauncher {
    open(onClosed?: () => void, onError?: (error: unknown) => void): void;
}
declare const LUX_CONSENT_DIALOG_LAUNCHER: InjectionToken<ILuxConsentDialogLauncher>;

declare class LuxConsentDialogLauncherService implements ILuxConsentDialogLauncher {
    private readonly dialogService;
    private readonly mediaService;
    open(onClosed?: () => void, onError?: (error: unknown) => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxConsentDialogLauncherService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxConsentDialogLauncherService>;
}

declare class LuxConsentDialogComponent implements OnInit {
    isExpanded: boolean;
    activeSection: 'consent' | 'datenschutz' | 'impressum';
    impressumComponentResolved?: Type<unknown>;
    datenschutzComponentResolved?: Type<unknown>;
    private readonly destroyRef;
    private readonly dialogRef;
    private readonly consentService;
    private readonly mediaQueryService;
    consentConfig: ILuxConsentConfig;
    mobileView: boolean;
    LuxConsentPurpose: typeof LuxConsentPurpose;
    LuxConsentStorageType: typeof LuxConsentStorageType;
    storageTypes: LuxConsentStorageType[];
    tableDataByPurposeAndType: Record<string, LuxConsentEntry[]>;
    combinedEntries: LuxConsentEntry[];
    hasNonEssentialEntries: boolean;
    cookieCategories: LuxCookieCategory[];
    ngOnInit(): void;
    private buildTableDataByPurposeAndType;
    getEntriesForPurposeAndType(purpose: LuxConsentPurpose, type: LuxConsentStorageType): LuxConsentEntry[];
    protected hasConfiguredEntriesForCategory(purpose: LuxConsentPurpose): boolean;
    toggleDetails(): void;
    acceptAll(): void;
    declineAll(): void;
    acceptSelected(): void;
    closeDialog(): void;
    private updateCategoriesFromState;
    protected findCategoryByPurpose(purpose: LuxConsentPurpose): LuxCookieCategory | undefined;
    protected toggleCategoryEnabled(purpose: LuxConsentPurpose, isEnabled: boolean): void;
    showSection(section: 'consent' | 'impressum' | 'datenschutz'): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxConsentDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxConsentDialogComponent, "lux-consent-dialog", never, {}, {}, never, never, true, never>;
}

declare const LUX_CONSENT_CONFIG: InjectionToken<ILuxConsentConfig>;
declare class LuxConsentService {
    private readonly cookieService;
    private readonly dialogLauncher;
    private readonly consentConfig;
    private consentState$;
    private runtimeConfigOverride?;
    constructor();
    getCurrentConfig(): ILuxConsentConfig;
    open(configOverride?: Partial<ILuxConsentConfig>): void;
    openIfNeeded(configOverride?: Partial<ILuxConsentConfig>): void;
    getConsentState(): Observable<LuxConsentState | null>;
    hasConsent(purpose: LuxConsentPurpose): boolean;
    /**
     * Prüft, ob der Consent-Dialog angezeigt werden soll.
     * Der Dialog wird angezeigt, wenn mindestens ein nicht-funktionaler Eintrag konfiguriert ist
     * und weder ein Consent-Cookie noch ein temporärer Session-Storage-Eintrag vorhanden ist.
     */
    shouldShowDialog(configOverride?: Partial<ILuxConsentConfig>): boolean;
    acceptAll(configOverride?: Partial<ILuxConsentConfig>): void;
    declineNonFunctional(configOverride?: Partial<ILuxConsentConfig>): void;
    saveCustomConsent(purposes: LuxConsentPurpose[], configOverride?: Partial<ILuxConsentConfig>): void;
    onCloseDialog(configOverride?: Partial<ILuxConsentConfig>): void;
    clearConsent(configOverride?: Partial<ILuxConsentConfig>): void;
    clearSessionConsent(configOverride?: Partial<ILuxConsentConfig>): void;
    private saveConsent;
    private getAcceptedPurposesForAcceptAll;
    private hasNonEssentialEntries;
    private loadConsent;
    private isValidConsentState;
    private resolveConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxConsentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxConsentService>;
}

interface LuxSvgIcon {
    iconName: string;
    iconPath: string;
    iconBasePath?: string;
}

declare class LuxIconRegistryService {
    private matIconRegistry;
    private sanitizer;
    private configService;
    private registeredIcons;
    private svgIcons;
    private iconBasePath;
    constructor();
    registerIcon(iconName: string): void;
    getSvgIconList(): LuxSvgIcon[];
    private normalizeIconName;
    private getIconBasePath;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxIconRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxIconRegistryService>;
}

declare class LuxIconComponent {
    private iconReg;
    private _luxIconSize;
    private _luxIconName;
    private _luxPadding;
    private _backgroundCSSClass;
    private _fontCSSClass;
    notFoundIconName: string;
    styleMargin: string;
    _luxRounded: boolean;
    luxColor?: LuxIconColor;
    set luxRounded(rounded: boolean);
    get luxRounded(): boolean;
    get luxMargin(): string;
    set luxMargin(margin: string);
    get luxPadding(): string;
    set luxPadding(padding: string);
    get luxIconSize(): string | undefined;
    set luxIconSize(iconSizeValue: string | undefined);
    get luxIconName(): string | undefined;
    set luxIconName(iconNameValue: string | undefined);
    luxLoad: EventEmitter<Event>;
    private registerIcon;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxIconComponent, "lux-icon", never, { "luxColor": { "alias": "luxColor"; "required": false; }; "luxRounded": { "alias": "luxRounded"; "required": false; }; "luxMargin": { "alias": "luxMargin"; "required": false; }; "luxPadding": { "alias": "luxPadding"; "required": false; }; "luxIconSize": { "alias": "luxIconSize"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; }, { "luxLoad": "luxLoad"; }, never, never, true, never>;
}

declare class LuxImageComponent implements OnChanges, OnInit {
    luxImageSrc: string;
    luxImageWidth: string;
    luxImageHeight: string;
    luxRawSrc: boolean;
    luxAlt: string;
    luxClicked: EventEmitter<Event>;
    isObserved: boolean;
    constructor();
    ngOnInit(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    clicked(event: Event): void;
    private updateImageSrc;
    private sanitizeImageSrc;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxImageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxImageComponent, "lux-image", never, { "luxImageSrc": { "alias": "luxImageSrc"; "required": false; }; "luxImageWidth": { "alias": "luxImageWidth"; "required": false; }; "luxImageHeight": { "alias": "luxImageHeight"; "required": false; }; "luxRawSrc": { "alias": "luxRawSrc"; "required": false; }; "luxAlt": { "alias": "luxAlt"; "required": false; }; }, { "luxClicked": "luxClicked"; }, never, never, true, never>;
}

declare class LuxTenantLogoComponent implements OnInit, OnDestroy {
    private componentsConfigService;
    private queryObserver;
    static buildTenantLogoUrlFromMediaQuery(baseUrl: string, tenantKey: string, tenantVariant: string | undefined, mediaQuery: string): string;
    static getVariantByMediaQuery(mediaQuery: string): string;
    static buildTenantLogoUrl(baseUrl: string, tenantKey: string, tenantVariant: string): string;
    private _luxTenantKey;
    set luxTenantKey(luxTenantKey: string);
    get luxTenantKey(): string;
    private _luxTenantVariant;
    set luxTenantVariant(luxTenantVariant: string | undefined);
    get luxTenantVariant(): string | undefined;
    actualLuxTenantLogoHeight: string;
    private _luxTenantLogoHeight;
    set luxTenantLogoHeight(luxTenantLogoHeight: string);
    get luxTenantLogoHeight(): string;
    luxTenantLogoClicked: EventEmitter<Event>;
    private apiPath?;
    private mediaQuery?;
    tenantLogoSrc: any;
    luxTenantLogoAriaLabel?: string;
    luxTenantLogoAlt: string;
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateSrc;
    private updateHeight;
    private updateAriaLabel;
    onImageClicked(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTenantLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTenantLogoComponent, "lux-tenant-logo", never, { "luxTenantKey": { "alias": "luxTenantKey"; "required": false; }; "luxTenantVariant": { "alias": "luxTenantVariant"; "required": false; }; "luxTenantLogoHeight": { "alias": "luxTenantLogoHeight"; "required": false; }; }, { "luxTenantLogoClicked": "luxTenantLogoClicked"; }, never, never, true, never>;
}

/**
 * Animation für das Aus- und Einklappen der LuxMessageBox.
 */
declare const visibilityTrigger: _angular_animations.AnimationTriggerMetadata;

declare type LuxModeType = MatAccordionDisplayMode;
declare type LuxTogglePosition = MatAccordionTogglePosition | undefined;
declare class LuxAccordionComponent implements AfterViewInit, OnDestroy {
    changed$: Subject<unknown>;
    private _luxColor?;
    luxMode: LuxModeType;
    luxMulti: boolean;
    set luxColor(value: LuxAccordionColor | undefined);
    get luxColor(): LuxAccordionColor | undefined;
    _luxDisabled?: boolean;
    _luxHideToggle?: boolean;
    _luxDynamicHeaderHeight?: boolean;
    _luxExpandedHeaderHeight?: string;
    _luxCollapsedHeaderHeight?: string;
    _luxTogglePosition?: LuxTogglePosition;
    get luxDisabled(): boolean | undefined;
    set luxDisabled(disabled: boolean | undefined);
    get luxHideToggle(): boolean | undefined;
    set luxHideToggle(hideToggle: boolean | undefined);
    get luxDynamicHeaderHeight(): boolean | undefined;
    set luxDynamicHeaderHeight(dynamicHeight: boolean | undefined);
    get luxExpandedHeaderHeight(): string | undefined;
    set luxExpandedHeaderHeight(height: string | undefined);
    get luxCollapsedHeaderHeight(): string | undefined;
    set luxCollapsedHeaderHeight(height: string | undefined);
    get luxTogglePosition(): LuxTogglePosition;
    set luxTogglePosition(position: LuxTogglePosition);
    matAccordion: MatAccordion;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAccordionComponent, "lux-accordion", never, { "luxMode": { "alias": "luxMode"; "required": false; }; "luxMulti": { "alias": "luxMulti"; "required": false; }; "luxColor": { "alias": "luxColor"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxHideToggle": { "alias": "luxHideToggle"; "required": false; }; "luxDynamicHeaderHeight": { "alias": "luxDynamicHeaderHeight"; "required": false; }; "luxExpandedHeaderHeight": { "alias": "luxExpandedHeaderHeight"; "required": false; }; "luxCollapsedHeaderHeight": { "alias": "luxCollapsedHeaderHeight"; "required": false; }; "luxTogglePosition": { "alias": "luxTogglePosition"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface LuxTheme {
    name: string;
    styleUrl: string;
}

declare class LuxThemeService {
    private storageService;
    private consentService;
    private readonly storageKeyThemeName;
    private themes;
    private theme$;
    constructor();
    getThemeAsObservable(): Observable<LuxTheme>;
    getTheme(): LuxTheme;
    setTheme(themeName: string): void;
    private findTheme;
    setThemes(themes: LuxTheme[]): void;
    loadTheme(): void;
    loadStyle(stylesUrl: string, parent?: HTMLElement): Promise<HTMLLinkElement>;
    private getInitTheme;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxThemeService>;
}

declare class LuxAppContentComponent implements OnInit, OnDestroy {
    private elementRef;
    private appService;
    private footerService;
    themeService: LuxThemeService;
    luxAriaRoleMainLabel: string;
    windowResize(): void;
    get getNoStickModeClass(): boolean;
    role?: string;
    label?: string;
    fixedMode: boolean;
    themeName: string;
    subscriptions: Subscription[];
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppContentComponent, "lux-app-content", never, { "luxAriaRoleMainLabel": { "alias": "luxAriaRoleMainLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface ILuxAppFooterButtonInfo {
    label: string;
    cmd: string;
    prio: number;
    color?: LuxThemePalette;
    disabled?: boolean;
    hidden?: boolean;
    raised?: boolean;
    flat?: boolean;
    stroked?: boolean;
    iconName?: string;
    alwaysVisible?: boolean;
    tooltip?: string;
    onClick?: (that: ILuxAppFooterButtonInfo) => void;
}
declare class LuxAppFooterButtonInfo implements ILuxAppFooterButtonInfo {
    label: string;
    color: LuxThemePalette;
    prio: number;
    disabled: boolean;
    cmd: string;
    hidden: boolean;
    raised: boolean;
    flat: boolean;
    stroked: boolean;
    iconName?: string;
    alwaysVisible: boolean;
    tooltip: string;
    tooltipMenu: string;
    onClick: (that: ILuxAppFooterButtonInfo) => void;
    constructor(label: string, cmd: string, prio?: number, color?: LuxThemePalette, disabled?: boolean, hidden?: boolean, raised?: boolean, flat?: boolean, stroked?: boolean, iconName?: string, alwaysVisible?: boolean, tooltip?: string, tooltipMenu?: string, onClick?: (that: ILuxAppFooterButtonInfo) => void);
    /**
     * Statische Methode um ein Info-Objekt zu generieren.
     * Nimmt ein Objekt vom Typ ILuxAppFooterButtonInfo entgegen.
     * @param data
     * @returns eine Button Info
     */
    static generateInfo(data: Partial<ILuxAppFooterButtonInfo>): LuxAppFooterButtonInfo;
}

declare class LuxAppFooterButtonService implements OnDestroy {
    private buttonInfoSubject;
    get buttonInfos(): LuxAppFooterButtonInfo[];
    set buttonInfos(buttonInfos: LuxAppFooterButtonInfo[]);
    getButtonInfosAsObservable(): Observable<LuxAppFooterButtonInfo[]>;
    ngOnDestroy(): void;
    pushButtonInfos(...value: LuxAppFooterButtonInfo[]): void;
    getButtonInfoByCMD(cmd: string): LuxAppFooterButtonInfo | undefined;
    removeButtonInfoAtIndex(i: number): void;
    removeButtonInfoByCmd(cmd: string): void;
    clearButtonInfos(): void;
    sendButtonCommand(buttonCommand: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppFooterButtonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxAppFooterButtonService>;
}

declare class LuxAppFooterFixedService implements OnDestroy {
    private configService;
    private mediaQueryService;
    private fixedModeSubject;
    subscriptions: Subscription[];
    constructor();
    ngOnDestroy(): void;
    get fixedMode(): boolean;
    get fixedModeAsObservable(): Observable<boolean>;
    private updateFixedMode;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppFooterFixedService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxAppFooterFixedService>;
}

interface ILuxAppFooterLinkInfo {
    label: string;
    path: string;
    alwaysVisible?: boolean;
    blank?: boolean;
    onClick?: (that: ILuxAppFooterLinkInfo) => void;
}
declare class LuxAppFooterLinkInfo implements ILuxAppFooterLinkInfo {
    label: string;
    path: string;
    alwaysVisible: boolean;
    blank: boolean;
    onClick?: (that: ILuxAppFooterLinkInfo) => void;
    constructor(label: string, path: string, alwaysVisible?: boolean, blank?: boolean, onClick?: (that: ILuxAppFooterLinkInfo) => void);
    /**
     * Statische Methode um ein Info-Objekt zu generieren.
     * Nimmt ein Objekt vom Typ ILuxAppFooterLinkInfo entgegen.
     * @param data
     * @returns eine Link Info
     */
    static generateInfo(data: ILuxAppFooterLinkInfo): LuxAppFooterLinkInfo;
}

declare class LuxAppFooterLinkService {
    private linkInfoSubject;
    get linkInfos(): LuxAppFooterLinkInfo[];
    set linkInfos(links: LuxAppFooterLinkInfo[]);
    getLinkInfosAsObservable(): Observable<LuxAppFooterLinkInfo[]>;
    pushLinkInfos(...links: LuxAppFooterLinkInfo[]): void;
    removeLinkInfoAtIndex(i: number): void;
    clearLinkInfos(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppFooterLinkService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxAppFooterLinkService>;
}

declare class LuxAppFooterComponent implements OnInit, AfterViewInit, OnDestroy {
    buttonService: LuxAppFooterButtonService;
    private linkService;
    private mediaObserver;
    private elementRef;
    private appService;
    private cdr;
    private configService;
    buttonMenu: LuxMenuComponent;
    luxVersion?: string;
    luxAriaRoleFooterLabel: string;
    luxCenteredView: boolean;
    luxCenteredWidth: string;
    desktopView?: boolean;
    buttonInfos: LuxAppFooterButtonInfo[];
    linkInfos: LuxAppFooterLinkInfo[];
    subscriptions: Subscription[];
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    sendButtonCommand(cmd: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppFooterComponent, "lux-app-footer", never, { "luxVersion": { "alias": "luxVersion"; "required": false; }; "luxAriaRoleFooterLabel": { "alias": "luxAriaRoleFooterLabel"; "required": false; }; "luxCenteredView": { "alias": "luxCenteredView"; "required": false; }; "luxCenteredWidth": { "alias": "luxCenteredWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAppHeaderAcSessionTimerComponent implements OnInit {
    private readonly luxSessionTimerService;
    private readonly mediaQueryService;
    private readonly tService;
    private readonly liveAnnouncer;
    private readonly destroyRef;
    private luxLoading;
    private mobileView;
    luxLogoutEvent: i0.OutputEmitterRef<void>;
    luxTimeoutEvent: i0.OutputEmitterRef<void>;
    constructor();
    ngOnInit(): void;
    protected isMobileView(): boolean;
    protected isLuxLoading(): boolean;
    protected showSessionTimer(): boolean;
    extendTimer(): void;
    getTimerLabel(): string;
    announceSessionTimer(): void;
    getTimerTooltip(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcSessionTimerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcSessionTimerComponent, "lux-app-header-ac-session-timer", never, {}, { "luxLogoutEvent": "luxLogoutEvent"; "luxTimeoutEvent": "luxTimeoutEvent"; }, never, never, true, never>;
}

declare class LuxAppHeaderAcActionNavComponent implements AfterViewInit {
    templateRef: TemplateRef<any>;
    menuItemComponents: QueryList<LuxAppHeaderAcActionNavItemComponent>;
    sessionTimerComponent?: LuxAppHeaderAcSessionTimerComponent;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcActionNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcActionNavComponent, "lux-app-header-ac-action-nav", never, {}, {}, ["sessionTimerComponent", "menuItemComponents"], ["lux-app-header-ac-session-timer", "lux-app-header-ac-action-nav-item"], true, never>;
}

declare class LuxAppHeaderAcNavMenuItemComponent extends LuxMenuItemComponent {
    luxSelected: boolean;
    luxButtonBadgeColor: LuxThemePalette;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcNavMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcNavMenuItemComponent, "lux-app-header-ac-nav-menu-item", never, { "luxSelected": { "alias": "luxSelected"; "required": false; }; "luxButtonBadgeColor": { "alias": "luxButtonBadgeColor"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class LuxAppHeaderAcNavMenuComponent implements OnDestroy {
    private queryService;
    menuItemComponents: QueryList<LuxAppHeaderAcNavMenuItemComponent>;
    luxNavMenuMaximumExtended: number;
    mobileView: boolean;
    subscription: Subscription;
    navMenuOpened: boolean;
    constructor();
    ngOnDestroy(): void;
    navMenuItemClicked(navItem: LuxAppHeaderAcNavMenuItemComponent, event: Event): void;
    onNavMenuOpend(): void;
    onNavMenuClosed(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcNavMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcNavMenuComponent, "lux-app-header-ac-nav-menu", never, { "luxNavMenuMaximumExtended": { "alias": "luxNavMenuMaximumExtended"; "required": false; }; }, {}, ["menuItemComponents"], never, true, never>;
}

declare const luxSessionTimerInterceptor: HttpInterceptorFn;

declare class LuxAppHeaderAcSessionTimerService {
    private readonly http;
    private readonly dialogService;
    private readonly configService;
    luxLogoutEvent: EventEmitter<void>;
    luxTimeoutEvent: EventEmitter<void>;
    private dialogIsOpen;
    private dialogWasClosed;
    private currentDialogRef;
    protected readonly startingSeconds: i0.WritableSignal<number>;
    private urlValue;
    private canExtendSessionValue;
    get url(): string;
    set url(value: string);
    get canExtendSession(): boolean;
    set canExtendSession(value: boolean);
    timeRemaining$: rxjs.Observable<number>;
    timeRemaining: Signal<number>;
    formattedMinutes: Signal<number>;
    formattedSeconds: Signal<number>;
    showSessionTimer: Signal<boolean>;
    showSeconds: Signal<boolean>;
    showHours: Signal<boolean>;
    dialogConfig: ILuxDialogConfig;
    constructor();
    extendSessionTimer(): rxjs.Observable<Object> | undefined;
    openDialog(): void;
    openNotExtendableDialog(): void;
    timeoutUser(): void;
    logoutUser(): void;
    resetTimer(seconds: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcSessionTimerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxAppHeaderAcSessionTimerService>;
}

declare class LuxAppHeaderAcUserMenuComponent {
    menuItemComponents: QueryList<LuxMenuItemComponent>;
    menuSectionComponents: QueryList<LuxMenuItemComponent | LuxDividerComponent | LuxMenuSectionTitleComponent>;
    luxUseSectionsAndHeaderPanel: i0.InputSignal<boolean>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcUserMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcUserMenuComponent, "lux-app-header-ac-user-menu", never, { "luxUseSectionsAndHeaderPanel": { "alias": "luxUseSectionsAndHeaderPanel"; "required": false; "isSignal": true; }; }, {}, ["menuItemComponents", "menuSectionComponents"], never, true, never>;
}

declare class LuxAppHeaderAcComponent implements OnInit, OnChanges {
    private logger;
    private queryService;
    private elementRef;
    private appService;
    private configService;
    luxUserName?: string;
    luxUserEmail?: string;
    luxAppTitle?: string;
    luxAppTitleShort?: string;
    luxBrandLogoSrc?: string;
    luxHideBrandLogo: boolean;
    luxAppLogoSrc?: string;
    luxHideAppLogo: boolean;
    luxLocaleSupported: string[];
    luxLocaleBaseHref: string;
    luxHideTopBar: boolean;
    luxHideNavBar: boolean;
    luxAriaRoleHeaderLabel: string;
    luxAriaUserMenuButtonLabel: string;
    luxAriaTitleIconLabel: string;
    luxAriaTitleImageLabel: string;
    luxCenteredView: boolean;
    luxCenteredWidth: string;
    luxAppLogoClicked: EventEmitter<Event>;
    luxBrandLogoClicked: EventEmitter<Event>;
    customTrigger?: ElementRef;
    tenantLogo?: LuxTenantLogoComponent;
    navMenu?: LuxAppHeaderAcNavMenuComponent;
    userMenu?: LuxAppHeaderAcUserMenuComponent;
    actionNav?: LuxAppHeaderAcActionNavComponent;
    userNameShort?: string;
    mobileView: boolean;
    subscriptions: Subscription[];
    menuOpened: boolean;
    private iconBasePath;
    constructor();
    ngOnInit(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    onMenuOpened(): void;
    onMenuClosed(): void;
    onAppLogoClicked(event: any): void;
    onBrandLogoClicked(event: any): void;
    isItemDivider(menuItem: any): menuItem is LuxDividerComponent;
    isItemMenuItem(menuItem: any): menuItem is LuxMenuItemComponent;
    isSectionTitle(menuItem: any): menuItem is LuxMenuSectionTitleComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderAcComponent, "lux-app-header-ac", never, { "luxUserName": { "alias": "luxUserName"; "required": false; }; "luxUserEmail": { "alias": "luxUserEmail"; "required": false; }; "luxAppTitle": { "alias": "luxAppTitle"; "required": false; }; "luxAppTitleShort": { "alias": "luxAppTitleShort"; "required": false; }; "luxBrandLogoSrc": { "alias": "luxBrandLogoSrc"; "required": false; }; "luxHideBrandLogo": { "alias": "luxHideBrandLogo"; "required": false; }; "luxAppLogoSrc": { "alias": "luxAppLogoSrc"; "required": false; }; "luxHideAppLogo": { "alias": "luxHideAppLogo"; "required": false; }; "luxLocaleSupported": { "alias": "luxLocaleSupported"; "required": false; }; "luxLocaleBaseHref": { "alias": "luxLocaleBaseHref"; "required": false; }; "luxHideTopBar": { "alias": "luxHideTopBar"; "required": false; }; "luxHideNavBar": { "alias": "luxHideNavBar"; "required": false; }; "luxAriaRoleHeaderLabel": { "alias": "luxAriaRoleHeaderLabel"; "required": false; }; "luxAriaUserMenuButtonLabel": { "alias": "luxAriaUserMenuButtonLabel"; "required": false; }; "luxAriaTitleIconLabel": { "alias": "luxAriaTitleIconLabel"; "required": false; }; "luxAriaTitleImageLabel": { "alias": "luxAriaTitleImageLabel"; "required": false; }; "luxCenteredView": { "alias": "luxCenteredView"; "required": false; }; "luxCenteredWidth": { "alias": "luxCenteredWidth"; "required": false; }; }, { "luxAppLogoClicked": "luxAppLogoClicked"; "luxBrandLogoClicked": "luxBrandLogoClicked"; }, ["tenantLogo", "navMenu", "userMenu", "actionNav"], ["lux-tenant-logo", "lux-app-header-ac-nav-menu"], true, never>;
}

declare class LuxAppHeaderActionNavComponent implements AfterViewInit {
    templateRef: TemplateRef<any>;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderActionNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderActionNavComponent, "lux-app-header-action-nav", never, {}, {}, never, ["lux-app-header-action-nav-item"], true, never>;
}

declare class LuxAppHeaderRightNavComponent {
    menuItemComponents: QueryList<LuxMenuItemComponent>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderRightNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderRightNavComponent, "lux-app-header-right-nav", never, {}, {}, ["menuItemComponents"], never, true, never>;
}

declare class LuxLocale {
    code: string;
    label: string;
    labelSelected: string;
    path: string;
    constructor(code: string, label: string, labelSelected: string, path: string);
}

declare class LuxLangSelectComponent implements OnInit {
    private cookieService;
    protected translocoService: TranslocoService;
    luxLocaleSupported: string[];
    luxLocaleBaseHref: string;
    cookieName: string;
    cookiePath: string;
    allSupportedLocaleArr: LuxLocale[];
    localeOptions: LuxLocale[];
    ngOnInit(): void;
    onLocaleChanged(locale: LuxLocale): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLangSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLangSelectComponent, "lux-lang-select", never, { "luxLocaleSupported": { "alias": "luxLocaleSupported"; "required": false; }; "luxLocaleBaseHref": { "alias": "luxLocaleBaseHref"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Animation für das Herein-Sliden der Seitennavigation von Links in den Contentbereich hinein und wieder zurück.
 */
declare const sideNavAnimation: _angular_animations.AnimationTriggerMetadata;
/**
 * Animation um das Overlay für die Sidebar ein- und auszublenden.
 */
declare const sideNavOverlayAnimation: _angular_animations.AnimationTriggerMetadata;

declare class LuxSideNavFooterComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSideNavFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSideNavFooterComponent, "lux-side-nav-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxSideNavHeaderComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSideNavHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSideNavHeaderComponent, "lux-side-nav-header", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxSideNavItemComponent implements AfterViewInit, OnChanges {
    private cdr;
    templateRef?: TemplateRef<any>;
    luxLabel?: string;
    luxDisabled: boolean;
    luxTagId?: string;
    luxSelected: boolean;
    luxCloseOnClick: boolean;
    luxIconName?: string;
    luxExpandable: boolean;
    luxExpanded: boolean;
    luxClicked: EventEmitter<Event>;
    sideNavItems: QueryList<LuxSideNavItemComponent>;
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    onClick(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSideNavItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSideNavItemComponent, "lux-side-nav-item", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxSelected": { "alias": "luxSelected"; "required": false; }; "luxCloseOnClick": { "alias": "luxCloseOnClick"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxExpandable": { "alias": "luxExpandable"; "required": false; }; "luxExpanded": { "alias": "luxExpanded"; "required": false; }; }, { "luxClicked": "luxClicked"; }, ["sideNavItems"], ["lux-divider", "lux-side-nav-item"], true, never>;
}

declare class LuxSideNavComponent implements AfterViewInit, OnDestroy {
    private appService;
    luxDashboardLink?: string;
    luxDashboardLinkTitle: string;
    luxOpenLinkBlank?: boolean;
    luxAriaRoleNavigationLabel: string;
    luxSideNavExpandedChange: EventEmitter<boolean>;
    sideNavItems: QueryList<LuxSideNavItemComponent>;
    directSideNavItems: QueryList<LuxSideNavItemComponent>;
    sideNavEl: ElementRef;
    sideNavHeaderEl: ElementRef;
    sideNavFooterEl: ElementRef;
    top?: string;
    left?: string;
    bottom?: string;
    right?: string;
    focusElement: any;
    height?: number;
    width?: number;
    visibility: string;
    _sideNavExpanded: boolean;
    get sideNavExpanded(): boolean;
    set sideNavExpanded(expanded: boolean);
    private itemClickSubscriptions;
    private subscription?;
    keyEvent(event: KeyboardEvent): void;
    windowResize(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    toggle(): void;
    private calculateAppMenuPosition;
    /**
     * Wenn die Animation beendet ist, wird das Menü ausgeblendet, damit der Fokus weiter zum Inhalt springt und nicht
     * durch das versteckte Menü wandert. Das ist auch für Screenreader nötig.
     */
    updateSideNavAfterAnimationIsFinished(): void;
    open(): void;
    close(): void;
    /**
     * Berechnet die Höhe für den Container der SideNavMenuItems.
     * Dafür wird die Gesamthöhe minus der Höhe des Headers und des Footers sowie eine feste Höhe
     * für den App-Header gerechnet.
     */
    private calculateWidthHeight;
    /**
     * Hängt sich an die Klick-Events der einzelnen SideNavItems, um so, je nach Einstellung der Items,
     * die SideNav zu schließen.
     */
    private updateItemClickListeners;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSideNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSideNavComponent, "lux-side-nav", never, { "luxDashboardLink": { "alias": "luxDashboardLink"; "required": false; }; "luxDashboardLinkTitle": { "alias": "luxDashboardLinkTitle"; "required": false; }; "luxOpenLinkBlank": { "alias": "luxOpenLinkBlank"; "required": false; }; "luxAriaRoleNavigationLabel": { "alias": "luxAriaRoleNavigationLabel"; "required": false; }; }, { "luxSideNavExpandedChange": "luxSideNavExpandedChange"; }, ["sideNavItems", "directSideNavItems"], ["lux-side-nav-header", "lux-side-nav-item", "lux-side-nav-footer"], true, never>;
}

declare class LuxAppHeaderComponent implements OnInit, OnChanges, OnDestroy {
    private queryService;
    private logger;
    private elementRef;
    private appService;
    luxLocaleSupported: string[];
    luxLocaleBaseHref: string;
    luxUserName?: string;
    luxAppTitle?: string;
    luxAppTitleShort?: string;
    luxIconName?: string;
    luxImageSrc?: string;
    luxImageHeight: string;
    luxAriaAppMenuButtonLabel: string;
    luxAriaUserMenuButtonLabel: string;
    luxAriaTitleIconLabel: string;
    luxAriaTitleImageLabel: string;
    luxAriaTitleLinkLabel: string;
    luxAriaRoleHeaderLabel: string;
    luxClicked: EventEmitter<Event>;
    mobileView: boolean;
    userNameShort?: string;
    hasOnClickedListener?: boolean;
    subscriptions: Subscription[];
    customTrigger?: ElementRef;
    actionNav?: LuxAppHeaderActionNavComponent;
    rightNav?: LuxAppHeaderRightNavComponent;
    sideNav?: LuxSideNavComponent;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    onMenuClosed(): void;
    onClicked(event: Event): void;
    private generateUserNameShort;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxAppHeaderComponent, "lux-app-header", never, { "luxLocaleSupported": { "alias": "luxLocaleSupported"; "required": false; }; "luxLocaleBaseHref": { "alias": "luxLocaleBaseHref"; "required": false; }; "luxUserName": { "alias": "luxUserName"; "required": false; }; "luxAppTitle": { "alias": "luxAppTitle"; "required": false; }; "luxAppTitleShort": { "alias": "luxAppTitleShort"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxImageSrc": { "alias": "luxImageSrc"; "required": false; }; "luxImageHeight": { "alias": "luxImageHeight"; "required": false; }; "luxAriaAppMenuButtonLabel": { "alias": "luxAriaAppMenuButtonLabel"; "required": false; }; "luxAriaUserMenuButtonLabel": { "alias": "luxAriaUserMenuButtonLabel"; "required": false; }; "luxAriaTitleIconLabel": { "alias": "luxAriaTitleIconLabel"; "required": false; }; "luxAriaTitleImageLabel": { "alias": "luxAriaTitleImageLabel"; "required": false; }; "luxAriaTitleLinkLabel": { "alias": "luxAriaTitleLinkLabel"; "required": false; }; "luxAriaRoleHeaderLabel": { "alias": "luxAriaRoleHeaderLabel"; "required": false; }; }, { "luxClicked": "luxClicked"; }, ["actionNav", "rightNav", "sideNav"], ["lux-app-header-right-nav", "lux-side-nav"], true, never>;
}

/**
 * Animation für das Aus- und Einklappen des erweiterten Karteninhalts.
 */
declare const expansionAnim: _angular_animations.AnimationTriggerMetadata;

type LuxCardActionAlignType = 'left' | 'right';
declare class LuxCardActionsComponent {
    luxAlign: i0.InputSignal<LuxCardActionAlignType>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardActionsComponent, "lux-card-actions", never, { "luxAlign": { "alias": "luxAlign"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class LuxCardContentExpandedComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardContentExpandedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardContentExpandedComponent, "lux-card-content-expanded", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxCardContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardContentComponent, "lux-card-content", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxCardCustomHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardCustomHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardCustomHeaderComponent, "lux-card-custom-header", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxCardHeadingComponent {
    luxLevel: i0.InputSignal<number>;
    luxText: i0.InputSignal<string | undefined>;
    luxTitle: i0.InputSignal<string | undefined>;
    luxClass: i0.InputSignal<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardHeadingComponent, "lux-card-heading", never, { "luxLevel": { "alias": "luxLevel"; "required": false; "isSignal": true; }; "luxText": { "alias": "luxText"; "required": false; "isSignal": true; }; "luxTitle": { "alias": "luxTitle"; "required": false; "isSignal": true; }; "luxClass": { "alias": "luxClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LuxCardInfoComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardInfoComponent, "lux-card-info", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxCardComponent implements OnInit, AfterViewInit, OnDestroy {
    private componentsConfigService;
    private cdr;
    private configSubscription?;
    luxTitle?: string;
    luxTitleTooltip?: string;
    luxSubTitle?: string;
    luxSubTitleTooltip?: string;
    luxIconName?: string;
    luxDisabled?: boolean;
    luxTagId?: string;
    luxTitleLineBreak: boolean;
    luxExpanded: boolean;
    luxUseTabIndex: boolean;
    luxHeading: number;
    luxExpandedLabelOpen: string;
    luxExpandedLabelClose: string;
    luxExpandedChange: EventEmitter<boolean>;
    luxAfterExpansion: EventEmitter<void>;
    luxClicked: EventEmitter<Event>;
    iconComponents: QueryList<LuxIconComponent>;
    actionsComponent?: LuxCardActionsComponent;
    infoComponent?: LuxCardInfoComponent;
    contentExpandedComponent?: LuxCardContentExpandedComponent;
    contentComponent?: LuxCardContentComponent;
    customHeaderComponent?: LuxCardCustomHeaderComponent;
    hasCardAction?: boolean;
    animationDisabled: boolean;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    get showButtons(): boolean;
    get showIcon(): boolean;
    get showExpandedToggle(): boolean;
    /**
     * Header wird nur angezeigt, wenn wenigstens eines der Header-Elemente vorhanden ist
     * (Icon, Title, Subtitle, Info-Komponente).
     */
    get showHeader(): boolean;
    changeContentExpansion(event: any): void;
    clicked(event: Event): void;
    /**
     * setzt das korrekte Alignment der Titelzeile. Ist der Titel im Zweifel mehrzeilig, so wird das Icon
     * im Titel nach oben ausgerichtet, damit es nicht mittig neben dem Titel schwebt. Ist der Titel aber
     * einzeilig, so wird das Icon vertikal zum Titel ausgerichtet.
     */
    getTitleAlignment(): string;
    /**
     * Gibt den Status der Animation zurück.
     */
    getAnimState(): string;
    /**
     * Gibt die Dauer der Animation abhängig davon, ob sie via Config deaktiviert wurden oder nicht zurück.
     */
    getAnimDuration(): 0 | 300;
    /**
     * Wird am Ende der Ausklapp-Animation aufgerufen und setzt das animationActive-Flag auf false und gibt ein Event
     * über den luxAfterExpansion-EventEmitter ab.
     */
    expansionDone(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCardComponent, "lux-card", never, { "luxTitle": { "alias": "luxTitle"; "required": false; }; "luxTitleTooltip": { "alias": "luxTitleTooltip"; "required": false; }; "luxSubTitle": { "alias": "luxSubTitle"; "required": false; }; "luxSubTitleTooltip": { "alias": "luxSubTitleTooltip"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxTitleLineBreak": { "alias": "luxTitleLineBreak"; "required": false; }; "luxExpanded": { "alias": "luxExpanded"; "required": false; }; "luxUseTabIndex": { "alias": "luxUseTabIndex"; "required": false; }; "luxHeading": { "alias": "luxHeading"; "required": false; }; "luxExpandedLabelOpen": { "alias": "luxExpandedLabelOpen"; "required": false; }; "luxExpandedLabelClose": { "alias": "luxExpandedLabelClose"; "required": false; }; }, { "luxExpandedChange": "luxExpandedChange"; "luxAfterExpansion": "luxAfterExpansion"; "luxClicked": "luxClicked"; }, ["actionsComponent", "infoComponent", "contentExpandedComponent", "contentComponent", "customHeaderComponent", "iconComponents"], ["lux-card-custom-header", "lux-icon", "lux-card-info", "lux-card-content", "lux-card-content-expanded", "lux-card-actions"], true, never>;
}

declare class LuxCheckboxContainerAcComponent {
    luxLabel: string;
    luxVertical: boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxCheckboxContainerAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxCheckboxContainerAcComponent, "lux-checkbox-container-ac", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxVertical": { "alias": "luxVertical"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class LuxListItemContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxListItemContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxListItemContentComponent, "lux-list-item-content", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxListItemCustomHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxListItemCustomHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxListItemCustomHeaderComponent, "lux-list-item-custom-header", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxListItemIconComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxListItemIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxListItemIconComponent, "lux-list-item-icon", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxListItemComponent implements FocusableOption {
    elementRef: ElementRef<any>;
    private _luxTitle;
    private _luxSubTitle;
    private _luxSelected;
    ariaLabel?: string;
    ariaSelected?: boolean;
    role: string;
    tabindex: string;
    luxTitleTooltip?: string;
    luxSubTitleTooltip?: string;
    luxTitleLineBreak: boolean;
    luxClicked: EventEmitter<Event>;
    customHeaderComponent?: LuxListItemCustomHeaderComponent;
    get luxTitle(): string;
    set luxTitle(title: string);
    get luxSubTitle(): string;
    set luxSubTitle(subTitle: string);
    get luxSelected(): boolean;
    set luxSelected(selected: boolean);
    clicked(event: Event): void;
    focus(): void;
    getLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxListItemComponent, "lux-list-item", never, { "luxTitleTooltip": { "alias": "luxTitleTooltip"; "required": false; }; "luxSubTitleTooltip": { "alias": "luxSubTitleTooltip"; "required": false; }; "luxTitleLineBreak": { "alias": "luxTitleLineBreak"; "required": false; }; "luxTitle": { "alias": "luxTitle"; "required": false; }; "luxSubTitle": { "alias": "luxSubTitle"; "required": false; }; "luxSelected": { "alias": "luxSelected"; "required": false; }; }, { "luxClicked": "luxClicked"; }, ["customHeaderComponent"], ["lux-list-item-custom-header", "lux-list-item-icon", "lux-list-item-content"], true, never>;
}

declare class LuxListComponent implements AfterViewInit, OnInit, OnDestroy {
    private tService;
    private _luxSelectedPosition;
    private previousFocusedPosition?;
    private clickSubscriptions;
    private listItemsSubscription?;
    private keyManager;
    luxItems: QueryList<LuxListItemComponent>;
    luxFocusedItemChange: EventEmitter<LuxListItemComponent>;
    luxFocusedPositionChange: EventEmitter<number>;
    luxSelectedPositionChange: EventEmitter<number>;
    luxEmptyIconName: string;
    luxEmptyIconSize: string;
    luxEmptyLabel: string;
    set luxLabel(value: string);
    role: string;
    tabindex: string;
    ariaMulti: string;
    label: string;
    onFocus(event: FocusEvent): void;
    onKeydown(keyboardEvent: KeyboardEvent): void;
    get luxSelectedPosition(): number;
    set luxSelectedPosition(position: number);
    constructor();
    isEmpty(): boolean;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Wird beim Drücken einer Taste ausgeführt und handelt die Aktionen bei speziellen Tasten
     * (UP_ARROW || DOWN_ARROW werden vom KeyManager selbstständig gepflegt)
     * @param keyboardEvent
     */
    keydown(keyboardEvent: KeyboardEvent): void;
    /**
     * Auf Click-Events der hier bekannten LuxListItems hören und entsprechend das selektierte ListItem aktualisieren.
     */
    private listenForClicks;
    /**
     * Merkt sich die Position als Selektionsposition und aktualisiert den luxSelected-Wert
     * aller luxItems, die hier bekannt sind.
     * @param position
     */
    private select;
    /**
     * Merkt sich die position als Fokus-Position und aktualisiert die CSS-Klassen der ListItems.
     * @param position
     */
    private focus;
    /**
     * Scrollt zu dem Element an der position.
     * @param position
     */
    private scroll;
    /**
     * Gibt das ListItem an der position zurück bzw. "null" wenn die luxItems undefined/null sind.
     * @param position
     */
    private findListItem;
    private getTagName;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxListComponent, "lux-list", never, { "luxEmptyIconName": { "alias": "luxEmptyIconName"; "required": false; }; "luxEmptyIconSize": { "alias": "luxEmptyIconSize"; "required": false; }; "luxEmptyLabel": { "alias": "luxEmptyLabel"; "required": false; }; "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxSelectedPosition": { "alias": "luxSelectedPosition"; "required": false; }; }, { "luxFocusedItemChange": "luxFocusedItemChange"; "luxFocusedPositionChange": "luxFocusedPositionChange"; "luxSelectedPositionChange": "luxSelectedPositionChange"; }, ["luxItems"], ["*"], true, never>;
}

declare class LuxDetailHeaderAcComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDetailHeaderAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDetailHeaderAcComponent, "lux-detail-header-ac", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxDetailViewAcComponent implements AfterContentInit {
    tempRef: TemplateRef<any>;
    constructor();
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDetailViewAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDetailViewAcComponent, "lux-detail-view-ac", never, {}, {}, ["tempRef"], never, true, never>;
}

declare class LuxDetailWrapperAcComponent implements OnInit, AfterViewInit {
    private _luxDetailTemplate;
    luxDetailRendered: EventEmitter<void>;
    luxDetailContext: any;
    set luxDetailTemplate(ref: TemplateRef<any>);
    get luxDetailTemplate(): TemplateRef<any>;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDetailWrapperAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDetailWrapperAcComponent, "lux-detail-wrapper-ac", never, { "luxDetailContext": { "alias": "luxDetailContext"; "required": false; }; "luxDetailTemplate": { "alias": "luxDetailTemplate"; "required": false; }; }, { "luxDetailRendered": "luxDetailRendered"; }, never, never, true, never>;
}

declare class LuxTabComponent {
    luxTitle: string;
    luxIconName?: string;
    luxCounter?: number;
    luxCounterCap: number;
    luxShowNotification?: boolean;
    luxDisabled: boolean;
    luxTagIdHeader?: string;
    luxTagIdContent?: string;
    luxImageSrc?: string;
    luxImageAlign: 'left' | 'center' | 'right';
    luxImageWidth: string;
    luxImageHeight: string;
    contentTemplate: TemplateRef<any>;
    constructor();
    onTabActivated(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTabComponent, "lux-tab", never, { "luxTitle": { "alias": "luxTitle"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; "luxCounter": { "alias": "luxCounter"; "required": false; }; "luxCounterCap": { "alias": "luxCounterCap"; "required": false; }; "luxShowNotification": { "alias": "luxShowNotification"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxTagIdHeader": { "alias": "luxTagIdHeader"; "required": false; }; "luxTagIdContent": { "alias": "luxTagIdContent"; "required": false; }; "luxImageSrc": { "alias": "luxImageSrc"; "required": false; }; "luxImageAlign": { "alias": "luxImageAlign"; "required": false; }; "luxImageWidth": { "alias": "luxImageWidth"; "required": false; }; "luxImageHeight": { "alias": "luxImageHeight"; "required": false; }; }, {}, ["contentTemplate"], never, true, never>;
}

declare class LuxTabsComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    componentsConfigService: LuxComponentsConfigService;
    private queryService;
    private static readonly _DEBOUNCE_TIME;
    private static _notificationNewClass;
    private static _notificationReadClass;
    private subscriptions;
    tabChange$: ReplaySubject<MatTabChangeEvent>;
    labelUppercase?: boolean;
    smallDevice?: boolean;
    luxActiveTab: number;
    luxIconSize: string;
    luxDisplayDivider: boolean;
    luxTagId?: string;
    luxLazyLoading: boolean;
    luxShowBorder: boolean;
    luxActiveTabChanged: EventEmitter<MatTabChangeEvent>;
    luxTabs: QueryList<LuxTabComponent>;
    tabHeader: ElementRef;
    ngOnInit(): void;
    ngOnChanges(simpleChanges: SimpleChanges): void;
    ngAfterViewInit(): void;
    private callOnTabActivated;
    ngOnDestroy(): void;
    getNotificationIconColorClassForTab(luxTab: LuxTabComponent): string;
    /**
     * Forciert Angular die Tab-Header neu zu prüfen, in dem
     * der erste Tab ein Leerzeichen bekommt, welches im nächsten
     * Prüfzyklus entfernt wird.
     */
    rerenderTabs(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTabsComponent, "lux-tabs", never, { "luxActiveTab": { "alias": "luxActiveTab"; "required": false; }; "luxIconSize": { "alias": "luxIconSize"; "required": false; }; "luxDisplayDivider": { "alias": "luxDisplayDivider"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxLazyLoading": { "alias": "luxLazyLoading"; "required": false; }; "luxShowBorder": { "alias": "luxShowBorder"; "required": false; }; }, { "luxActiveTabChanged": "luxActiveTabChanged"; }, ["luxTabs"], never, true, never>;
}

declare class LuxMasterHeaderAcComponent implements OnDestroy {
    private mediaObserver;
    private tService;
    iconName?: string;
    open?: boolean;
    subscription: Subscription;
    luxToggleHidden?: boolean;
    luxOpened: EventEmitter<boolean>;
    headerContentContainer: ElementRef;
    isMobile?: boolean;
    constructor();
    ngOnDestroy(): void;
    getAriaLabelForOpenCloseButton(iconName?: string): string;
    clicked(that: LuxButtonComponent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMasterHeaderAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMasterHeaderAcComponent, "lux-master-header-ac", never, { "luxToggleHidden": { "alias": "luxToggleHidden"; "required": false; }; }, { "luxOpened": "luxOpened"; }, never, ["*"], true, never>;
}

declare class LuxMasterListAcComponent {
    luxTitleProp?: string;
    luxTitleTooltipProp?: string;
    luxSubTitleProp?: string;
    luxSubTitleTooltipProp?: string;
    contentTempRef?: TemplateRef<any>;
    iconTempRef?: TemplateRef<any>;
    customHeaderTempRef?: TemplateRef<any>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMasterListAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMasterListAcComponent, "lux-master-list-ac", never, { "luxTitleProp": { "alias": "luxTitleProp"; "required": false; }; "luxTitleTooltipProp": { "alias": "luxTitleTooltipProp"; "required": false; }; "luxSubTitleProp": { "alias": "luxSubTitleProp"; "required": false; }; "luxSubTitleTooltipProp": { "alias": "luxSubTitleTooltipProp"; "required": false; }; }, {}, ["contentTempRef", "iconTempRef", "customHeaderTempRef"], never, true, never>;
}

declare class LuxMasterDetailAcComponent<T = any> implements OnInit, AfterContentInit, AfterViewInit, DoCheck, OnDestroy {
    private cdr;
    private cfr;
    private liveAnnouncer;
    private mediaObserver;
    luxSelectedDetailChange: EventEmitter<T | null>;
    luxScrolled: EventEmitter<void>;
    masterSimple?: LuxMasterListAcComponent;
    detailView: LuxDetailViewAcComponent;
    masterFooter?: ElementRef;
    detailHeader?: ElementRef;
    luxMasterQueryList: QueryList<ElementRef>;
    luxMasterListItemQueryList: QueryList<LuxListItemComponent>;
    masterHeader?: ElementRef;
    masterHeaderComponent?: LuxMasterHeaderAcComponent;
    luxMasterEntryElementRef?: ElementRef;
    tabsComponent?: LuxTabsComponent;
    masterSpinnerCard?: ElementRef;
    detailFrame?: ElementRef;
    detailEmpty?: ElementRef;
    detailViewContainerRef: ViewContainerRef;
    masterContainer?: ElementRef;
    private _luxOpen;
    private _luxMasterList;
    private _luxSelectedDetail;
    private masterListLength;
    private maxItemsVisible?;
    private updateDetail$;
    private subscriptions;
    isMobile: boolean;
    isMedium: boolean;
    detailContext: {
        $implicit: {};
    };
    showMasterHeader?: boolean;
    selectedPosition: number;
    alignEmptyIndicators: boolean;
    luxEmptyIconMaster: string;
    luxEmptyLabelMaster: string;
    luxEmptyIconDetail: string;
    luxEmptyLabelDetail: string;
    luxEmptyIconMasterSize: string;
    luxEmptyIconDetailSize: string;
    luxMasterSpinnerDelay: number;
    luxTagIdMaster?: string;
    luxTagIdDetail?: string;
    luxTitleLineBreak: boolean;
    luxMasterListLabel: string;
    luxMasterIsLoading: boolean;
    luxCompareWith: (o1: T, o2: T) => boolean;
    luxDefaultDetailHeader: boolean;
    get luxOpen(): boolean;
    set luxOpen(open: boolean);
    get luxSelectedDetail(): T | null;
    set luxSelectedDetail(value: T | null);
    get luxMasterList(): any[];
    set luxMasterList(value: any[]);
    constructor();
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngDoCheck(): void;
    /**
     * Wenn in der LuxList ein neuer Selected-Wert gepusht wird, diesen abfangen und
     * ein neues Detail auswählen.
     * @param index
     */
    onSelectedChange(index: number): void;
    onOpenMaster(): void;
    onCloseMaster(): void;
    /**
     * Bestimmt, ob die Masterliste auf- oder eingeklappt ist.
     * @param open
     */
    toggleList(open: boolean): void;
    /**
     * Prüft, ob die Detailansicht gerade für den User sichtbar ist.
     * @returns boolean
     */
    isDetailInvisible(): boolean;
    onInfiniteScrollingLoad(): void;
    onSwipeLeft(): void;
    onSwipeRight(): void;
    /**
     * Kapselung von der übergebenen luxCompareWith-Funktion.
     * Fängt undefinierte Objekte ab und returned stattdessen false.
     * @param o1
     * @param o2
     */
    compareObjects(o1: T | null, o2: T | null): boolean;
    /**
     * Kümmert sich um Änderungen an der HTML-Node der Master-Liste.
     * Rückt dabei das selektierte Element in den Fokus und berechnet wie viele Elemente
     * gerade in der Liste sichtbar sein können (für das Durchschalten mit Pfeiltasten benötigt).
     */
    private handleMasterQueryList;
    /**
     * Kümmert sich um Änderungen an dem selektierten Detail.
     * Dabei werden mehrere Zuweisungen an das Detail über throttleTime gebündelt und nur das Aktuellste genommen.
     * Anschließend wird die Komponente angewiesen das neue Detail-Objekt zu rendern.
     */
    private handleDetailUpdate;
    /**
     * Wird aufgerufen, nachdem ein neues Detail-Template gerendert wurde und aktualisiert
     * luxSelectedDetail dementsprechend.
     * @param detail
     */
    private setNewDetail;
    /**
     * Kümmert sich um den Fall, dass die Master-Liste selbst sich ändert.
     */
    private handleMasterListUpdate;
    /**
     * Prüft, ob das Header- oder -Footer-Element der Masterliste ca. 50 % der Master-Höhe einnehmen.
     *
     * Wenn ja, wird die Ausrichtung des Master-Empty-Labels und Master-Empty-Icons nicht mehr anhand des Details bestimmt.
     */
    private checkEmptyIndicatorAlignment;
    /**
     * Meldet über den LiveAnnouncer, dass evtl. weitere Daten via InfiniteScrolling nachgeladen werden könnten.
     *
     * "assertive", damit die Meldung auf jeden Fall vom ScreenReader vorgelesen wird und nicht von etwaigen anderen
     * Aussagen verdeckt wird.
     */
    private announcePossibleInfiniteScrolling;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMasterDetailAcComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMasterDetailAcComponent<any>, "lux-master-detail-ac", never, { "luxEmptyIconMaster": { "alias": "luxEmptyIconMaster"; "required": false; }; "luxEmptyLabelMaster": { "alias": "luxEmptyLabelMaster"; "required": false; }; "luxEmptyIconDetail": { "alias": "luxEmptyIconDetail"; "required": false; }; "luxEmptyLabelDetail": { "alias": "luxEmptyLabelDetail"; "required": false; }; "luxEmptyIconMasterSize": { "alias": "luxEmptyIconMasterSize"; "required": false; }; "luxEmptyIconDetailSize": { "alias": "luxEmptyIconDetailSize"; "required": false; }; "luxMasterSpinnerDelay": { "alias": "luxMasterSpinnerDelay"; "required": false; }; "luxTagIdMaster": { "alias": "luxTagIdMaster"; "required": false; }; "luxTagIdDetail": { "alias": "luxTagIdDetail"; "required": false; }; "luxTitleLineBreak": { "alias": "luxTitleLineBreak"; "required": false; }; "luxMasterListLabel": { "alias": "luxMasterListLabel"; "required": false; }; "luxMasterIsLoading": { "alias": "luxMasterIsLoading"; "required": false; }; "luxCompareWith": { "alias": "luxCompareWith"; "required": false; }; "luxDefaultDetailHeader": { "alias": "luxDefaultDetailHeader"; "required": false; }; "luxOpen": { "alias": "luxOpen"; "required": false; }; "luxSelectedDetail": { "alias": "luxSelectedDetail"; "required": false; }; "luxMasterList": { "alias": "luxMasterList"; "required": false; }; }, { "luxSelectedDetailChange": "luxSelectedDetailChange"; "luxScrolled": "luxScrolled"; }, ["masterSimple", "detailView", "masterFooter", "detailHeader", "tabsComponent"], ["lux-master-header-content-ac", "lux-master-footer-ac", "lux-detail-header-ac"], true, never>;
}

declare class LuxMasterFooterAcComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMasterFooterAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMasterFooterAcComponent, "lux-master-footer-ac", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxMasterHeaderContentAcComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMasterHeaderContentAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxMasterHeaderContentAcComponent, "lux-master-header-content-ac", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxPanelActionComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPanelActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxPanelActionComponent, "lux-panel-action", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxPanelContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPanelContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxPanelContentComponent, "lux-panel-content", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxPanelHeaderDescriptionComponent implements AfterViewInit {
    luxTruncated: i0.InputSignal<boolean>;
    luxTruncatedTooltip: i0.InputSignal<string>;
    matPanelDescription: i0.Signal<ElementRef<any> | undefined>;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPanelHeaderDescriptionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxPanelHeaderDescriptionComponent, "lux-panel-header-description", never, { "luxTruncated": { "alias": "luxTruncated"; "required": false; "isSignal": true; }; "luxTruncatedTooltip": { "alias": "luxTruncatedTooltip"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class LuxPanelHeaderTitleComponent implements AfterViewInit {
    luxTruncated: i0.InputSignal<boolean>;
    luxTruncatedTooltip: i0.InputSignal<string>;
    matPanelTitle: i0.Signal<ElementRef<any> | undefined>;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPanelHeaderTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxPanelHeaderTitleComponent, "lux-panel-header-title", never, { "luxTruncated": { "alias": "luxTruncated"; "required": false; "isSignal": true; }; "luxTruncatedTooltip": { "alias": "luxTruncatedTooltip"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class LuxMediaQueryObserverService implements OnDestroy {
    private breakpointObserver;
    private logger;
    static BREAKPOINTS_ALL: string[];
    static BREAKPOINTS_DEFAULT: string[];
    protected _mediaQueryChanged: BehaviorSubject<string>;
    protected _mediaQueryAllChanged: BehaviorSubject<string>;
    protected _subscriptions: Subscription[];
    constructor();
    get activeMediaQuery(): string;
    ngOnDestroy(): void;
    getMediaQueryChangedAsObservable(...breakpoints: string[]): Observable<string>;
    isSmaller(query: string): boolean;
    isSmallerOrEqual(query: string): boolean;
    isGreater(query: string): boolean;
    isGreaterOrEqual(query: string): boolean;
    private sizeAsNumber;
    isXS(): boolean;
    isSM(): boolean;
    isMD(): boolean;
    isLG(): boolean;
    isXL(): boolean;
    isHandset(): boolean;
    isTablet(): boolean;
    isWeb(): boolean;
    isHandsetPortrait(): boolean;
    isTabletPortrait(): boolean;
    isWebPortrait(): boolean;
    isHandsetLandscape(): boolean;
    isTabletLandscape(): boolean;
    isWebLandscape(): boolean;
    private addQuerySubscription;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxMediaQueryObserverService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxMediaQueryObserverService>;
}

declare class LuxPanelComponent implements OnInit, AfterViewInit, OnDestroy {
    protected parent: LuxAccordionComponent | null;
    protected mediaQuery: LuxMediaQueryObserverService;
    _luxDynamicHeaderHeight?: boolean;
    headerHeightCacheActive: boolean;
    expandedHeaderHeightCache?: string;
    collapsedHeaderHeightCache?: string;
    luxDisabled?: boolean;
    luxExpanded: boolean;
    luxHideToggle?: boolean;
    luxTogglePosition?: LuxTogglePosition;
    luxCollapsedHeaderHeight?: string;
    luxExpandedHeaderHeight?: string;
    set luxDynamicHeaderHeight(value: boolean | undefined);
    get luxDynamicHeaderHeight(): boolean | undefined;
    luxOpened: EventEmitter<void>;
    luxClosed: EventEmitter<void>;
    luxExpandedChange: EventEmitter<boolean>;
    matExpansionPanel: MatExpansionPanel;
    subscriptions: Subscription[];
    mobile: boolean;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    protected getMatExpansionPanel(): MatExpansionPanel;
    ngOnDestroy(): void;
    onOpened(): void;
    onClosed(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxPanelComponent, "lux-panel", never, { "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxExpanded": { "alias": "luxExpanded"; "required": false; }; "luxHideToggle": { "alias": "luxHideToggle"; "required": false; }; "luxTogglePosition": { "alias": "luxTogglePosition"; "required": false; }; "luxCollapsedHeaderHeight": { "alias": "luxCollapsedHeaderHeight"; "required": false; }; "luxExpandedHeaderHeight": { "alias": "luxExpandedHeaderHeight"; "required": false; }; "luxDynamicHeaderHeight": { "alias": "luxDynamicHeaderHeight"; "required": false; }; }, { "luxOpened": "luxOpened"; "luxClosed": "luxClosed"; "luxExpandedChange": "luxExpandedChange"; }, never, ["lux-panel-header-title", "lux-panel-header-description", "lux-panel-content", "lux-panel-action"], true, never>;
}

declare const LUX_STEPPER_LARGE_DEFAULT_PREV_BTN_CONF: LuxStepperLargeButtonInfo;
declare const LUX_STEPPER_LARGE_DEFAULT_NEXT_BTN_CONF: LuxStepperLargeButtonInfo;
declare const LUX_STEPPER_LARGE_DEFAULT_FIN_BTN_CONF: LuxStepperLargeButtonInfo;
declare class LuxStepperLargeButtonInfo {
    label?: string;
    color?: LuxThemePalette;
    iconName?: string;
    iconShowRight?: boolean;
    alignIconWithLabel?: boolean;
}

declare enum LuxVetoState {
    navigationAccepted = 0,
    navigationRejected = 1
}
interface ILuxStepperLargeStep {
    luxTitle: string;
    luxTouched: boolean;
    luxCompleted: boolean;
    luxDisabled: boolean;
    luxVetoFn: (clickEvent: LuxStepperLargeClickEvent) => Promise<LuxVetoState>;
    contentTemplate: TemplateRef<any>;
}

declare class LuxStepperLargeSelectionEvent {
    stepper: LuxStepperLargeComponent;
    currentIndex: number;
    currentStep: ILuxStepperLargeStep;
    prevIndex: number;
    prevStep: ILuxStepperLargeStep;
    constructor(stepper: LuxStepperLargeComponent, currentIndex: number, currentStep: ILuxStepperLargeStep, prevIndex: number, prevStep: ILuxStepperLargeStep);
}

declare class LuxStepperLargeComponent implements OnInit, AfterContentInit, OnDestroy {
    private mobileOverlayService;
    private queryService;
    private liveAnnouncer;
    private snackbar;
    private tService;
    steps: QueryList<ILuxStepperLargeStep>;
    luxStepValidationActive: boolean;
    luxA11YMode: boolean;
    luxPrevButtonConfig: _ihk_gfi_lux_components.LuxStepperLargeButtonInfo;
    luxNextButtonConfig: _ihk_gfi_lux_components.LuxStepperLargeButtonInfo;
    luxFinButtonConfig: _ihk_gfi_lux_components.LuxStepperLargeButtonInfo;
    luxStepperFinished: EventEmitter<void>;
    luxStepChanged: EventEmitter<LuxStepperLargeSelectionEvent>;
    luxCurrentStepNumberChange: EventEmitter<number>;
    luxOnNextStepNotComplete: EventEmitter<number>;
    _luxCurrentStepNumber: number;
    get luxCurrentStepNumber(): number;
    set luxCurrentStepNumber(stepNumber: number);
    isMobile: boolean;
    isFirstStep: boolean;
    isLastStep: boolean;
    isFinished: boolean;
    cursorPos: number;
    subscriptions: Subscription[];
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    onPrevStep(): void;
    onNextStep(): void;
    onFinStep(): void;
    onNavFocusin(index: number): void;
    onNavFocusout(index: number): void;
    onNavLinkEnter(stepIndex: number): void;
    onNavLink(stepIndex: number): void;
    onOpenMobileOverlay(): void;
    onResetStepper(): void;
    onNavKeyUp(): void;
    onNavKeyDown(): void;
    private activatePrevStep;
    private activateNextStep;
    private finishStepper;
    private getPrevIndex;
    private getNextIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperLargeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperLargeComponent, "lux-stepper-large", never, { "luxStepValidationActive": { "alias": "luxStepValidationActive"; "required": false; }; "luxA11YMode": { "alias": "luxA11YMode"; "required": false; }; "luxPrevButtonConfig": { "alias": "luxPrevButtonConfig"; "required": false; }; "luxNextButtonConfig": { "alias": "luxNextButtonConfig"; "required": false; }; "luxFinButtonConfig": { "alias": "luxFinButtonConfig"; "required": false; }; "luxCurrentStepNumber": { "alias": "luxCurrentStepNumber"; "required": false; }; }, { "luxStepperFinished": "luxStepperFinished"; "luxStepChanged": "luxStepChanged"; "luxCurrentStepNumberChange": "luxCurrentStepNumberChange"; "luxOnNextStepNotComplete": "luxOnNextStepNotComplete"; }, ["steps"], never, true, never>;
}

type LuxStepperLargeClickEventSourceType = 'nav' | 'prev_button' | 'next_button' | 'fin_button';
declare class LuxStepperLargeClickEvent {
    stepper: LuxStepperLargeComponent;
    newIndex: number;
    newStep: ILuxStepperLargeStep;
    source: LuxStepperLargeClickEventSourceType;
    constructor(stepper: LuxStepperLargeComponent, newIndex: number, newStep: ILuxStepperLargeStep, source: LuxStepperLargeClickEventSourceType);
}

declare const LUX_STEPPER_LARGE_OVERLAY_DATA: InjectionToken<LuxStepperLargeMobileOverlayData>;
interface LuxStepperLargeMobileOverlayData {
    stepperComponent: LuxStepperLargeComponent;
}

declare const LUX_STEPPER_LARGE_OVERLAY_DEFAULT_CONFIG: LuxStepperLargeMobileOverlayConfig;
interface LuxStepperLargeMobileOverlayConfig {
    panelClass?: string;
    hasBackdrop?: boolean;
    backdropClass?: string;
    data?: LuxStepperLargeMobileOverlayData;
}

declare class LuxStepperLargeMobileOverlayRef {
    private overlayRef;
    focusedElement: Element | null;
    constructor(overlayRef: OverlayRef);
    close(): void;
}

declare class LuxStepperLargeMobileOverlayComponent implements OnInit, AfterViewInit {
    overlayRef: LuxStepperLargeMobileOverlayRef;
    data: LuxStepperLargeMobileOverlayData;
    links: QueryList<ElementRef>;
    stepperComponent: LuxStepperLargeComponent;
    handleKeydown(keyboardEvent: KeyboardEvent): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onNavLink(stepIndex: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperLargeMobileOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperLargeMobileOverlayComponent, "lux-stepper-large-mobile-overlay", never, {}, {}, never, never, true, never>;
}

declare class LuxStepperLargeMobileOverlayService {
    private injector;
    private overlay;
    open(config: LuxStepperLargeMobileOverlayConfig): LuxStepperLargeMobileOverlayRef;
    private attachDialogContainer;
    private createOverlay;
    private createInjector;
    private getOverlayConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperLargeMobileOverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxStepperLargeMobileOverlayService>;
}

declare class LuxStepperLargeStepComponent implements ILuxStepperLargeStep, AfterViewInit {
    contentTemplate: TemplateRef<any>;
    luxTitle: string;
    luxTouched: boolean;
    luxCompleted: boolean;
    luxDisabled: boolean;
    luxVetoFn: (clickEvent: LuxStepperLargeClickEvent) => Promise<LuxVetoState>;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperLargeStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperLargeStepComponent, "lux-stepper-large-step", never, { "luxTitle": { "alias": "luxTitle"; "required": false; }; "luxTouched": { "alias": "luxTouched"; "required": false; }; "luxCompleted": { "alias": "luxCompleted"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxVetoFn": { "alias": "luxVetoFn"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Kennzeichnet die möglichen Optionen, um die Navigations-Buttons des Steppers zu konfigurieren.
 */

interface ILuxStepperButtonConfig {
    label?: string;
    color?: LuxThemePalette;
    iconName?: string;
    alignIconWithLabel?: boolean;
}

declare class LuxStepComponent {
    private _iconChange;
    private _luxIconName?;
    headerTemplate: TemplateRef<any>;
    contentTemplate: TemplateRef<any>;
    luxIconSize: string;
    luxOptional: boolean;
    luxEditable: boolean;
    luxCompleted: boolean;
    luxStepControl?: FormGroup;
    get luxIconName(): string | undefined;
    set luxIconName(iconName: string | undefined);
    getIconChangeObsv(): Observable<boolean>;
    constructor();
    /**
     * Gibt an, ob der Step als abgeschlossen gilt.
     *
     * Möglichkeiten:
     *  1. Hat ein luxStepControl, welches valid ist
     *  2. Der Wert luxCompleted ist true
     *  3. Der Wert luxOptional ist true
     */
    isCompleted(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepComponent, "lux-step", never, { "luxIconSize": { "alias": "luxIconSize"; "required": false; }; "luxOptional": { "alias": "luxOptional"; "required": false; }; "luxEditable": { "alias": "luxEditable"; "required": false; }; "luxCompleted": { "alias": "luxCompleted"; "required": false; }; "luxStepControl": { "alias": "luxStepControl"; "required": false; }; "luxIconName": { "alias": "luxIconName"; "required": false; }; }, {}, never, ["lux-step-header", "lux-step-content"], true, never>;
}

/**
 * Enthält die für den LuxStepper (und damit für den horizontalen und vertikalen Stepper) verfügbaren
 * Input-Properties.
 */
interface ILuxStepperConfiguration {
    luxCurrentStepNumber?: number;
    luxUseCustomIcons?: boolean;
    luxEditedIconName?: string;
    luxVerticalStepper?: boolean;
    luxLinear?: boolean;
    luxDisabled?: boolean;
    luxShowNavigationButtons?: boolean;
    luxHorizontalStepAnimationActive?: boolean;
    luxPreviousButtonConfig?: ILuxStepperButtonConfig;
    luxNextButtonConfig?: ILuxStepperButtonConfig;
    luxFinishButtonConfig?: ILuxStepperButtonConfig;
    luxSteps?: LuxStepComponent[];
}

declare class LuxStepperComponent implements AfterViewInit, OnDestroy, OnInit {
    stepperService: LuxStepperHelperService;
    private cdr;
    private cfr;
    private elementRef;
    private queryService;
    private readonly _DEFAULT_PREV_BTN_CONF;
    private readonly _DEFAULT_NEXT_BTN_CONF;
    private readonly _DEFAULT_FIN_BTN_CONF;
    luxSteps: QueryList<LuxStepComponent>;
    luxFinishButtonClicked: EventEmitter<void>;
    luxStepChanged: EventEmitter<StepperSelectionEvent>;
    luxCurrentStepNumberChange: EventEmitter<number>;
    luxCheckValidation: EventEmitter<number>;
    luxStepClicked: EventEmitter<number>;
    matStepper: MatStepper;
    matStepLabels: ViewContainerRef[];
    matStepHeaders: CdkStepHeader[];
    stepperConfiguration: ILuxStepperConfiguration;
    private subscriptions;
    mobileView?: boolean;
    subscription?: Subscription;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    fixRoleAttributes(): void;
    ngOnDestroy(): void;
    /**
     * Wird beim Wechsel des aktuellen Steps (Klick auf Tab oder .next()/.previous() Aufruf) aufgerufen.
     * @param selectionEvent
     */
    onStepChanged(selectionEvent: StepperSelectionEvent): void;
    /**
     * Generiert die individuellen Icons für die Steps.
     */
    generateCustomIcons(): void;
    /**
     * Entfernt die eigenen Icons für die Steps.
     */
    clearCustomIcons(): void;
    /**
     * Stößt die Validierungsprüfung für den aktuell sichtbaren Step und dessen StepControl (wenn vorhanden) an.
     */
    checkValidation(): void;
    onStepClicked(event: number): void;
    /**
     * Generiert die Icons für einen einzelnen Step
     * @param stepLabel
     * @param luxStep
     * @param factory
     */
    private generateCustomIconForStep;
    /**
     * Aktualisiert die aktuellen Icons, entfernt zunächst die individuellen Icons und
     * versucht anschließend diese neu zu generieren (nötig bei Änderungen).
     */
    private updateIcons;
    private setFocusedCSS;
    /**** Getter/Setter luxCurrentStepNumber ****/
    get luxCurrentStepNumber(): number;
    set luxCurrentStepNumber(step: number);
    /**** Getter/Setter luxUseCustomIcons ****/
    get luxUseCustomIcons(): boolean;
    set luxUseCustomIcons(use: boolean);
    /**** Getter/Setter luxEditedIconName ****/
    get luxEditedIconName(): string;
    set luxEditedIconName(iconName: string);
    /**** Getter/Setter luxVerticalStepper ****/
    get luxVerticalStepper(): boolean;
    set luxVerticalStepper(vertical: boolean);
    /**** Getter/Setter luxLinear ****/
    get luxLinear(): boolean;
    set luxLinear(linear: boolean);
    /**** Getter/Setter luxDisabled ****/
    get luxDisabled(): boolean;
    set luxDisabled(disabled: boolean);
    /**** Getter/Setter luxShowNavigationButtons ****/
    get luxShowNavigationButtons(): boolean;
    set luxShowNavigationButtons(showNavButtons: boolean);
    /**** Getter/Setter luxHorizontalStepAnimationActive ****/
    get luxHorizontalStepAnimationActive(): boolean;
    set luxHorizontalStepAnimationActive(animationActive: boolean);
    /**** Getter/Setter luxPreviousButtonConfig ****/
    get luxPreviousButtonConfig(): ILuxStepperButtonConfig | undefined;
    set luxPreviousButtonConfig(config: ILuxStepperButtonConfig | undefined);
    /**** Getter/Setter luxNextButtonConfig ****/
    get luxNextButtonConfig(): ILuxStepperButtonConfig | undefined;
    set luxNextButtonConfig(config: ILuxStepperButtonConfig | undefined);
    /**** Getter/Setter luxFinishButtonConfig ****/
    get luxFinishButtonConfig(): ILuxStepperButtonConfig | undefined;
    set luxFinishButtonConfig(config: ILuxStepperButtonConfig | undefined);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperComponent, "lux-stepper", never, { "luxCurrentStepNumber": { "alias": "luxCurrentStepNumber"; "required": false; }; "luxUseCustomIcons": { "alias": "luxUseCustomIcons"; "required": false; }; "luxEditedIconName": { "alias": "luxEditedIconName"; "required": false; }; "luxVerticalStepper": { "alias": "luxVerticalStepper"; "required": false; }; "luxLinear": { "alias": "luxLinear"; "required": false; }; "luxDisabled": { "alias": "luxDisabled"; "required": false; }; "luxShowNavigationButtons": { "alias": "luxShowNavigationButtons"; "required": false; }; "luxHorizontalStepAnimationActive": { "alias": "luxHorizontalStepAnimationActive"; "required": false; }; "luxPreviousButtonConfig": { "alias": "luxPreviousButtonConfig"; "required": false; }; "luxNextButtonConfig": { "alias": "luxNextButtonConfig"; "required": false; }; "luxFinishButtonConfig": { "alias": "luxFinishButtonConfig"; "required": false; }; }, { "luxFinishButtonClicked": "luxFinishButtonClicked"; "luxStepChanged": "luxStepChanged"; "luxCurrentStepNumberChange": "luxCurrentStepNumberChange"; "luxCheckValidation": "luxCheckValidation"; "luxStepClicked": "luxStepClicked"; }, ["luxSteps"], ["lux-step"], true, never>;
}

declare class LuxStepperHelperService {
    private switchStep;
    constructor();
    /**
     * Springt im Stepper zum nächsten Step.
     * Alternativ (ohne Stepper als Parameter) lässt die Funktion alle
     * bekannten Stepper einen Schritt nach vorne springen.
     *
     * Voraussetzung: luxLinear = false oder aktuell Form ist valide.
     * @param stepper
     */
    nextStep(stepper?: LuxStepperComponent): void;
    /**
     * Springt im Stepper zum vorherigen Step.
     * Alternativ (ohne Stepper als Parameter) lässt die Funktion alle
     * Bekannten Stepper einen Schritt zurückspringen.
     * @param stepper
     */
    previousStep(stepper?: LuxStepperComponent): void;
    /**
     * Gibt das Observable der internen Map für den Stepper zurück.
     * @param stepper
     * @returns Observable<boolean> | Observable<any>
     */
    getObservable(stepper: LuxStepperComponent): Observable<boolean | null>;
    /**
     * Trägt den Stepper in die Map der dem Service bekannten Stepper ein.
     * @param stepper
     */
    registerStepper(stepper: LuxStepperComponent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperHelperService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxStepperHelperService>;
}

/**
 * Parent-Klasse für den LuxStepperVertical und LuxStepperHorizontal, beide Komponenten werden ausschließlich von
 * dem LuxStepper zur Darstellung genutzt.
 */
declare class LuxStepperParent implements OnDestroy, AfterViewInit {
    luxFinButtonClicked: EventEmitter<void>;
    luxNextButtonClicked: EventEmitter<void>;
    luxPrevButtonClicked: EventEmitter<void>;
    luxStepChanged: EventEmitter<StepperSelectionEvent>;
    luxMatStepperLoaded: EventEmitter<MatStepper>;
    luxMatStepLabelsLoaded: EventEmitter<ViewContainerRef[]>;
    luxStepClicked: EventEmitter<number>;
    matStepper: MatStepper;
    matStepLabels: QueryList<ViewContainerRef>;
    luxStepperConfig?: ILuxStepperConfiguration;
    subscription?: Subscription;
    constructor();
    ngAfterViewInit(): void;
    onStepClicked(event: Event): void;
    ngOnDestroy(): void;
    private getStepIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperParent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxStepperParent, never, never, { "luxStepperConfig": { "alias": "luxStepperConfig"; "required": false; }; }, { "luxFinButtonClicked": "luxFinButtonClicked"; "luxNextButtonClicked": "luxNextButtonClicked"; "luxPrevButtonClicked": "luxPrevButtonClicked"; "luxStepChanged": "luxStepChanged"; "luxMatStepperLoaded": "luxMatStepperLoaded"; "luxMatStepLabelsLoaded": "luxMatStepLabelsLoaded"; "luxStepClicked": "luxStepClicked"; }, never, never, true, never>;
}

declare class LuxStepContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepContentComponent, "lux-step-content", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxStepHeaderComponent implements OnInit, OnDestroy {
    componentsConfigService: LuxComponentsConfigService;
    private configSubscription?;
    labelUppercase?: boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepHeaderComponent, "lux-step-header", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxStepperHorizontalComponent extends LuxStepperParent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperHorizontalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperHorizontalComponent, "lux-stepper-horizontal", never, {}, {}, never, never, true, never>;
}

declare class LuxStepperNavButtonsComponent {
    luxPrevClick: EventEmitter<void>;
    luxNextClick: EventEmitter<void>;
    luxFinClick: EventEmitter<void>;
    luxIndex: number;
    luxStep: LuxStepComponent;
    luxStepperConfig?: ILuxStepperConfiguration;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperNavButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperNavButtonsComponent, "lux-stepper-nav-buttons", never, { "luxIndex": { "alias": "luxIndex"; "required": false; }; "luxStep": { "alias": "luxStep"; "required": false; }; "luxStepperConfig": { "alias": "luxStepperConfig"; "required": false; }; }, { "luxPrevClick": "luxPrevClick"; "luxNextClick": "luxNextClick"; "luxFinClick": "luxFinClick"; }, never, never, true, never>;
}

declare class LuxStepperVerticalComponent extends LuxStepperParent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStepperVerticalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxStepperVerticalComponent, "lux-stepper-vertical", never, {}, {}, never, never, true, never>;
}

declare class LuxTileAcComponent implements OnInit, OnChanges, OnDestroy {
    private queryService;
    luxLabel?: string;
    luxLabelTruncateAfterOneLine: boolean;
    luxLabelTruncateAfterTwoLines: boolean;
    luxSubTitle?: string;
    luxSubTitleTruncateAfterOneLine: boolean;
    luxSubTitleTruncateAfterTwoLines: boolean;
    luxTagId?: string;
    set luxShowNotification(value: boolean);
    get luxShowNotification(): boolean;
    set luxCounter(counter: number | undefined);
    get luxCounter(): number | undefined;
    luxCounterCap: number;
    luxNotificationColor: LuxBadgeNotificationColor;
    luxNotificationSize: LuxBadgeNotificationSize;
    private _showNotification;
    private _counter?;
    luxBadgeContent: string;
    luxClicked: EventEmitter<Event>;
    mobileView?: boolean;
    subscription?: Subscription;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    clicked(): void;
    getBadgeContent(): string;
    private updateBadgeContent;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTileAcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTileAcComponent, "lux-tile-ac", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxLabelTruncateAfterOneLine": { "alias": "luxLabelTruncateAfterOneLine"; "required": false; }; "luxLabelTruncateAfterTwoLines": { "alias": "luxLabelTruncateAfterTwoLines"; "required": false; }; "luxSubTitle": { "alias": "luxSubTitle"; "required": false; }; "luxSubTitleTruncateAfterOneLine": { "alias": "luxSubTitleTruncateAfterOneLine"; "required": false; }; "luxSubTitleTruncateAfterTwoLines": { "alias": "luxSubTitleTruncateAfterTwoLines"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxShowNotification": { "alias": "luxShowNotification"; "required": false; }; "luxCounter": { "alias": "luxCounter"; "required": false; }; "luxCounterCap": { "alias": "luxCounterCap"; "required": false; }; "luxNotificationColor": { "alias": "luxNotificationColor"; "required": false; }; "luxNotificationSize": { "alias": "luxNotificationSize"; "required": false; }; }, { "luxClicked": "luxClicked"; }, never, ["lux-icon", "lux-image"], true, never>;
}

declare class LuxTileComponent implements OnInit, OnDestroy {
    private queryService;
    private static _notificationNewClass;
    private static _notificationReadClass;
    luxLabel?: string;
    luxLabelTruncateAfterOneLine: boolean;
    luxLabelTruncateAfterTwoLines: boolean;
    luxTagId?: string;
    luxShowNotification?: boolean;
    luxCounter?: number;
    luxCounterCap: number;
    luxShowShadow: boolean;
    luxClicked: EventEmitter<Event>;
    mobileView?: boolean;
    subscription?: Subscription;
    ngOnInit(): void;
    ngOnDestroy(): void;
    clicked(): void;
    getNotificationIconColorClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTileComponent, "lux-tile", never, { "luxLabel": { "alias": "luxLabel"; "required": false; }; "luxLabelTruncateAfterOneLine": { "alias": "luxLabelTruncateAfterOneLine"; "required": false; }; "luxLabelTruncateAfterTwoLines": { "alias": "luxLabelTruncateAfterTwoLines"; "required": false; }; "luxTagId": { "alias": "luxTagId"; "required": false; }; "luxShowNotification": { "alias": "luxShowNotification"; "required": false; }; "luxCounter": { "alias": "luxCounter"; "required": false; }; "luxCounterCap": { "alias": "luxCounterCap"; "required": false; }; "luxShowShadow": { "alias": "luxShowShadow"; "required": false; }; }, { "luxClicked": "luxClicked"; }, never, ["lux-icon", "lux-image"], true, never>;
}

declare class LuxAutocompleteErrorStateMatcherAc extends LuxLookupErrorStateMatcher {
    entries: LuxLookupTableEntry[];
    constructor(lookupComponent: LuxLookupComponent<any>, entries: LuxLookupTableEntry[]);
    isErrorState(control: FormControl | UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
}

declare class LuxLookupLabelComponent implements OnInit {
    private readonly destroyRef;
    lookupService: LuxLookupService;
    lookupHandler: LuxLookupHandlerService;
    logger: LuxConsoleService;
    lookupParameters?: LuxLookupParameters;
    entry?: LuxLookupTableEntry;
    init: boolean;
    _luxLookupKnr: number;
    _luxTableKey: string;
    _luxTableNo: string;
    _luxFields?: LuxFieldValues[];
    luxLookupId: string;
    luxLookupUrl: string;
    luxBezeichnung: string;
    get luxLookupKnr(): number;
    set luxLookupKnr(knr: number);
    get luxTableNo(): string;
    set luxTableNo(tableNo: string);
    get luxTableKey(): string;
    set luxTableKey(key: string);
    get luxFields(): LuxFieldValues[] | undefined;
    set luxFields(fields: LuxFieldValues[] | undefined);
    constructor();
    ngOnInit(): void;
    protected fetchLookupData(): void;
    /**
     * liefert die Bezeichnung (Kurz- oder Langbezeichnung) des Entries für den Key zur Tabelle.
     * @returns string
     */
    getBezeichnung(): string;
    private isReadyToFetch;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxLookupLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxLookupLabelComponent, "lux-lookup-label", never, { "luxLookupId": { "alias": "luxLookupId"; "required": false; }; "luxLookupUrl": { "alias": "luxLookupUrl"; "required": false; }; "luxBezeichnung": { "alias": "luxBezeichnung"; "required": false; }; "luxLookupKnr": { "alias": "luxLookupKnr"; "required": false; }; "luxTableNo": { "alias": "luxTableNo"; "required": false; }; "luxTableKey": { "alias": "luxTableKey"; "required": false; }; "luxFields": { "alias": "luxFields"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxAlphabeticallySortedPipe implements PipeTransform {
    transform(array: any[]): any;
    private sortAlphabetically;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAlphabeticallySortedPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuxAlphabeticallySortedPipe, "luxAlphabeticallySorted", true>;
}

declare class LuxPropertyFromObjectPipe implements PipeTransform {
    /**
     * Ruft die Funktion aus Util auf, um ein Property aus einem Objekt (auch mit Unterpfaden) auszulesen.
     * @param object
     * @param propertyNamePath
     */
    transform(object: any, propertyNamePath: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPropertyFromObjectPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuxPropertyFromObjectPipe, "luxPropertyFromObject", true>;
}

declare const MS_PER_DAY: number;
declare const timeDeltas: {
    id: string;
    days: number;
    dayUnit: number;
}[];
declare const timeDeltasRelative: {
    id: string;
    days: number;
}[];
declare class LuxRelativeTimestampPipe implements PipeTransform, OnDestroy {
    private tService;
    private cdr;
    private langSub?;
    private lastArgs?;
    private lastResult;
    constructor();
    transform(timestamp: number | null, defaultText?: string, prefix?: string): string;
    private compute;
    private calcDiff;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxRelativeTimestampPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuxRelativeTimestampPipe, "luxRelativeTimestamp", true>;
}

declare class LuxRenderPropertyPipe implements PipeTransform {
    transform(value: any, renderPropertyName: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxRenderPropertyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuxRenderPropertyPipe, "luxRenderProperty", true>;
}

/**
 * Config-Interface für die Dialog-Actions in der LuxDialogPresetComponent.
 */

interface ILuxDialogAction {
    label?: string;
    color?: LuxThemePalette;
    raised?: boolean;
    iconName?: string;
    tagId?: string;
    disabled?: boolean;
    rounded?: boolean;
    flat?: boolean;
    outlined?: boolean;
}

declare type LuxDialogDefaultButton = 'confirm' | 'decline' | undefined;
/**
 * Config-Interface für die LuxDialogPresetComponent.
 */
interface ILuxDialogPresetConfig extends ILuxDialogConfig {
    confirmAction?: ILuxDialogAction;
    declineAction?: ILuxDialogAction;
    defaultButton?: LuxDialogDefaultButton;
    title?: string;
    iconName?: string;
    content?: string;
    contentTemplate?: TemplateRef<any>;
}
declare const DEFAULT_DIALOG_PRESET_CONF: ILuxDialogPresetConfig;

/**
 * Diese Component wird von dem LuxDialogService zur Darstellung via "open" genutzt und nimmt ein Config-Objekt
 * vom Typ LuxDialogConfig entgegen.
 */
declare class LuxDialogPresetComponent implements OnInit, AfterViewInit {
    dialogRef: LuxDialogRef<ILuxDialogPresetConfig>;
    confirmButton?: LuxButtonComponent;
    declineButton?: LuxButtonComponent;
    data?: ILuxDialogPresetConfig;
    defaultButton?: LuxButtonComponent;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Schließt den Dialog beim "positiven" Beenden des Dialogs mit dem Wert true.
     */
    onConfirmClick(): void;
    /**
     * Schließt den Dialog beim "negativen" Beenden des Dialogs mit dem Wert false.
     */
    onDeclineClick(): void;
    private initDefaultButton;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogPresetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDialogPresetComponent, "lux-dialog-preset", never, {}, {}, never, never, true, never>;
}

declare class LuxDialogActionsComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDialogActionsComponent, "lux-dialog-actions", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxDialogContentComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDialogContentComponent, "lux-dialog-content", never, {}, {}, never, ["*"], true, never>;
}

declare class LuxDialogTitleComponent {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDialogTitleComponent, "lux-dialog-title", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Diese Component stellt eine Grundstruktur für Dialoge dar und kann von Aufrufern als Alternative
 * zu LuxDialogPresetComponent genutzt werden (wenn andere Inhalte, etc. gewünscht sind).
 */
declare class LuxDialogStructureComponent implements OnInit, AfterViewInit {
    private luxDialogRef;
    dialogBase: ElementRef;
    disableClose: boolean;
    private _iconName;
    set luxDialogIcon(name: string | undefined);
    get luxDialogIcon(): string | undefined;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogStructureComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxDialogStructureComponent, "lux-dialog-structure", never, { "luxDialogIcon": { "alias": "luxDialogIcon"; "required": false; }; }, {}, never, ["lux-dialog-title", "lux-dialog-content", "lux-dialog-actions"], true, never>;
}

declare class LuxDialogService {
    private parentInjector;
    private matDialog;
    /**
     * Öffnet einen Dialog basierend auf der übergebenen Component und den entsprechenden Daten.
     * @param component
     * @param config
     * @param data
     */
    openComponent<T>(component: ComponentType<any>, config?: ILuxDialogConfig, data?: T): LuxDialogRef<T>;
    /**
     * @deprecated Wird nicht mehr benötigt, da die Dialogreferenz nicht mehr zwischengespeichert wird.
     */
    storeDialogRef(): void;
    /**
     * @deprecated Wird nicht mehr benötigt, da die Dialogreferenz nicht mehr zwischengespeichert wird.
     */
    restoreDialogRef(): void;
    /**
     * Öffnet einen Dialog basierend auf der LuxDialogComponent und der LuxDialogConfig.
     * @param config
     */
    open<T>(config?: ILuxDialogPresetConfig): LuxDialogRef<T>;
    /**
     * Prüft, ob bereits ein Dialog geöffnet ist und etwaige CSS-Klassen für den Dialog gegeben sind.
     * Anschließend wird der Dialog mit den übergebenen Config-Optionen und Data-Informationen geöffnet.
     * @param component
     * @param config
     * @param data
     * @param defaultConfig
     */
    private handleOpen;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxDialogService>;
}

declare class LuxPopupActionsDirective {
    readonly templateRef: TemplateRef<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPopupActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxPopupActionsDirective, "ng-template[luxPopupActions]", ["luxPopupActions"], {}, {}, never, never, true, never>;
}

type LuxPopupPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
type LuxPopupCloseReason = 'program' | 'pointer-leave' | 'trigger-blur' | 'outside' | 'escape' | 'toggle' | 'scroll';

declare class LuxPopupComponent implements OnDestroy {
    private overlay;
    private viewContainerRef;
    private zone;
    private dir;
    private document;
    private scrollDispatcher;
    actions?: LuxPopupActionsDirective;
    popupTemplate: TemplateRef<unknown>;
    readonly luxTitle: i0.InputSignal<string | undefined>;
    readonly luxPersistent: i0.InputSignal<boolean>;
    readonly luxMinWidth: i0.InputSignal<number>;
    readonly luxMaxWidth: i0.InputSignal<number>;
    readonly luxAriaLabel: i0.InputSignal<string | undefined>;
    luxOpened: EventEmitter<void>;
    luxClosed: EventEmitter<LuxPopupCloseReason>;
    popupId: string;
    private overlayRef?;
    private portal?;
    private documentPointerDownListener?;
    private documentKeydownListener?;
    private currentTrigger?;
    private pendingCloseReason;
    private focusedElementBeforeOpen?;
    private scrollSubscription?;
    constructor();
    get role(): 'dialog' | 'tooltip';
    get minWidthPx(): number;
    get maxWidthPx(): number;
    open(trigger: LuxPopupTriggerDirective): void;
    close(reason?: LuxPopupCloseReason): void;
    toggle(trigger: LuxPopupTriggerDirective): void;
    private shouldRestoreFocus;
    isOpen(): boolean;
    isOpenFor(trigger: LuxPopupTriggerDirective): boolean;
    ngOnDestroy(): void;
    private handleOverlayDetached;
    private buildOverlayConfig;
    private buildPreferredPositions;
    private mapPosition;
    private resolvePanelClasses;
    private syncPanelClasses;
    private addOverlayListeners;
    private removeOverlayListeners;
    private handleDocumentPointerDown;
    private handleDocumentKeydown;
    private applyOverlaySize;
    private focusPopupIfNeeded;
    handlePopupKeydown(event: KeyboardEvent): void;
    private focusTriggerElement;
    private getFocusableElements;
    private isFocusable;
    private subscribeToScrollEvents;
    private unsubscribeFromScrollEvents;
    private setupOverlaySizeEffect;
    private setupPersistentClassEffect;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxPopupComponent, "lux-popup", ["luxPopup"], { "luxTitle": { "alias": "luxTitle"; "required": false; "isSignal": true; }; "luxPersistent": { "alias": "luxPersistent"; "required": false; "isSignal": true; }; "luxMinWidth": { "alias": "luxMinWidth"; "required": false; "isSignal": true; }; "luxMaxWidth": { "alias": "luxMaxWidth"; "required": false; "isSignal": true; }; "luxAriaLabel": { "alias": "luxAriaLabel"; "required": false; "isSignal": true; }; }, { "luxOpened": "luxOpened"; "luxClosed": "luxClosed"; }, ["actions"], ["*"], true, never>;
}

declare class LuxPopupTriggerDirective implements OnDestroy {
    private popup?;
    private showTimeoutId?;
    private hideTimeoutId?;
    private activePopup?;
    readonly luxPopupTriggerFor: i0.InputSignal<LuxPopupComponent | undefined>;
    readonly luxPopupPosition: i0.InputSignal<LuxPopupPosition>;
    readonly luxPopupShowDelay: i0.InputSignal<number>;
    readonly luxPopupHideDelay: i0.InputSignal<number>;
    readonly luxPopupDisabled: i0.InputSignal<boolean>;
    get ariaHasPopup(): "dialog" | "true" | undefined;
    ariaControls?: string;
    ariaExpanded?: 'true' | 'false';
    readonly elementRef: ElementRef<HTMLElement>;
    constructor();
    open(): void;
    close(reason?: LuxPopupCloseReason): void;
    toggle(): void;
    onPopupOpened(component: LuxPopupComponent): void;
    onPopupClosed(_reason: LuxPopupCloseReason): void;
    handleMouseEnter(): void;
    handleMouseLeave(): void;
    handleFocusIn(): void;
    handleFocusOut(event: FocusEvent): void;
    handleClick(event: Event): void;
    handleLongPress(): void;
    handleTouchEnd(): void;
    ngOnDestroy(): void;
    private shouldIgnorePointerInteraction;
    private scheduleShow;
    private scheduleHide;
    private clearTimers;
    private clearShowTimeout;
    private clearHideTimeout;
    private applyAriaExpanded;
    private setupPopupBindingEffect;
    private setupDisabledEffect;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPopupTriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxPopupTriggerDirective, "[luxPopupTriggerFor]", ["luxPopupTrigger"], { "luxPopupTriggerFor": { "alias": "luxPopupTriggerFor"; "required": false; "isSignal": true; }; "luxPopupPosition": { "alias": "luxPopupPosition"; "required": false; "isSignal": true; }; "luxPopupShowDelay": { "alias": "luxPopupShowDelay"; "required": false; "isSignal": true; }; "luxPopupHideDelay": { "alias": "luxPopupHideDelay"; "required": false; "isSignal": true; }; "luxPopupDisabled": { "alias": "luxPopupDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LuxSnackbarConfig {
    iconName?: string;
    iconSize?: string;
    iconColor?: string;
    text?: string;
    textColor?: string;
    action?: string;
    actionColor?: string;
    constructor(partial: Partial<LuxSnackbarConfig>);
}

declare class LuxSnackbarComponent implements OnInit {
    config: LuxSnackbarConfig;
    snackbarRef: MatSnackBarRef<LuxSnackbarComponent>;
    private action$;
    ngOnInit(): void;
    onAction(): Observable<void>;
    actionClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSnackbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxSnackbarComponent, "lux-snackbar", never, {}, {}, never, never, true, never>;
}

/**
 * Über den LuxSnackbarService können einfach Snackbar-Informationen angezeigt werden.
 */
declare class LuxSnackbarService implements OnDestroy {
    private snackBar;
    private appService;
    private static readonly VERTICAL_POSITION;
    private static readonly HORIZONTAL_POSITION;
    private afterOpenedSubscription?;
    private resizeSubscription;
    constructor();
    /**
     * Diese Methode öffnet eine Snackbar mit einem Text.
     * @param message Ein Text.
     * @param duration Eine Dauer in Msec (z.B. 2000 = 2 Sekunden). Wenn die Snackbar permanent angezeigt werden soll,
     * muss der Wert 0 angegeben werden.
     * @param actionName Eine Bezeichnung (z.B. Wiederherstellen) für die Action. Dieser Parameter ist optional und
     * muss nicht angegeben werden.
     */
    openText(message: string, duration: number, actionName?: string): void;
    /**
     * Diese Methode öffnet eine Snackbar, in der die übergebene Komponente angezeigt wird.
     * @param component Die Komponente, die angezeigt werden soll.
     * @param duration Eine Dauer in Msec (z.B. 2000 = 2 Sekunden). Wenn die Snackbar permanent angezeigt werden soll,
     * muss der Wert 0 angegeben werden.
     * @param data Ein Datenobjekt, das an die Komponente weitergereicht wird. Mit dem Code folgenden Code können die
     * Daten verwendet werden. constructor(@Inject(MAT_SNACK_BAR_DATA) public data: any).
     */
    openComponent(component: ComponentType<any>, duration?: number, data?: any): void;
    /**
     * Öffnet eine Snackbar anhand der übergebenen Konfiguration.
     * Ermöglicht eine genaue Konfiguration der Snackbar.
     * @param duration
     * @param config
     */
    open(duration: number, config?: LuxSnackbarConfig): void;
    /**
     * Diese Methode liefert ein Observable zurück, das den Aufrufer benachrichtigt, wenn die Action in der Snackbar
     * geklickt wird.
     */
    onAction(): Observable<void>;
    /**
     * Diese Methode liefert ein Observable zurück, das den Aufrufer benachrichtigt, wenn die Action in der Snackbar
     * geklickt wird.
     */
    afterDismissed(): Observable<MatSnackBarDismiss>;
    /**
     * Diese Methode blendet die Snackbar aus.
     */
    dismiss(): void;
    ngOnDestroy(): void;
    private updateSnackbarPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxSnackbarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxSnackbarService>;
}

declare class LuxTourHintComponent implements OnInit, AfterViewInit {
    private cdr;
    private element;
    tourHintRef: LuxTourHintRef<any>;
    private _luxTarget;
    set luxTarget(luxTarget: any);
    get luxTarget(): any;
    arrowClass: string;
    private arrowLength;
    private shadowPadding;
    tourHintPosLeft: number;
    tourHintPosTop: number;
    bgTopSize: number;
    bgBottomSize: number;
    bgLeftSize: number;
    bgRightSize: number;
    bgContentHeight: number;
    dynamicArrowStyle: {};
    private tourHintContainer;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private updateTargetAndPositions;
    private calculatePositions;
    private getSurroundingBounds;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTourHintComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTourHintComponent, "lux-tour-hint", never, {}, {}, never, ["*"], true, never>;
}

interface ILuxTourHintStepConfig {
    targetId: string;
    data?: any;
}

interface InitializedTourHintConfig {
    targetId: string;
    target: any;
    data?: any;
}
declare class LuxTourHintService {
    private appRef;
    private injector;
    private tourHintRef;
    private storage;
    private consentService;
    tourContainer?: ComponentRef<LuxTourHintComponent>;
    constructor();
    private onPageNavigate;
    open(tourConfig: ILuxTourHintStepConfig | ILuxTourHintStepConfig[], optionDontShowAgain?: boolean): LuxTourHintRef;
    openComponent(comp: ComponentType<any>, tourConfig: ILuxTourHintStepConfig | ILuxTourHintStepConfig[], optionDontShowAgain?: boolean): LuxTourHintRef;
    private prepareConfigs;
    private getDontShowAgainId;
    private onTourElementKeyPress;
    private dsaCallback;
    clearDSACacheForConfig(tourConfig: ILuxTourHintStepConfig | ILuxTourHintStepConfig[]): void;
    close(dontShowAgain?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTourHintService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxTourHintService>;
}

type OnCloseListener = (dontShowAgain: boolean) => void;
declare class LuxTourHintRef<T = any> {
    get target(): any;
    get data(): T;
    get step(): number;
    get steps(): number;
    private _opened;
    get opened(): boolean;
    private tourHintContainer?;
    private tourStep;
    private tourStepConfigs;
    private _optionDontShowAgain;
    get optionDontShowAgain(): boolean;
    private dontShowAgainCallback;
    private onCloseListeners;
    constructor();
    init(tourHintContainer: LuxTourHintComponent, configs: InitializedTourHintConfig[], optionDontShowAgain: boolean, dontShowAgainCallback: () => void): void;
    private updateTour;
    hasNext(): boolean;
    hasPrevious(): boolean;
    next(): void;
    prev(): void;
    close(dontShowAgain?: boolean): void;
    onClose(listener: OnCloseListener): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTourHintRef<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxTourHintRef<any>>;
}

declare class LuxTourHintPresetComponent {
    tourRef: LuxTourHintRef<any>;
    dontShowAgainChecked: boolean;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTourHintPresetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxTourHintPresetComponent, "lux-tour-hint-preset", never, {}, {}, never, never, true, never>;
}

interface ILuxBreadcrumbEntry {
    name: string;
    url?: string;
}

declare class LuxBreadcrumbComponent implements OnDestroy {
    private mediaQueryService;
    luxEntries?: ILuxBreadcrumbEntry[];
    /**
     * Aktiviert eine mehrzeilige Darstellung (Umbruch). Standard: einzeilig mit Truncation.
     */
    luxWrap: boolean;
    /**
     * Zeigt nur den ersten und den letzten Eintrag an. Alle dazwischenliegenden Einträge werden als Platzhalter ("...") dargestellt.
     */
    luxShowOnlyFirstAndLast: boolean;
    luxClicked: EventEmitter<ILuxBreadcrumbEntry>;
    mobileView: boolean;
    subscriptions: Subscription[];
    constructor();
    isCollapsedMode(): boolean;
    isDottedEntry(isFirst: boolean, isLast: boolean): boolean;
    onEntryClick(event: Event, item: ILuxBreadcrumbEntry): void;
    clicked(item: ILuxBreadcrumbEntry): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxBreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxBreadcrumbComponent, "lux-breadcrumb", never, { "luxEntries": { "alias": "luxEntries"; "required": false; }; "luxWrap": { "alias": "luxWrap"; "required": false; }; "luxShowOnlyFirstAndLast": { "alias": "luxShowOnlyFirstAndLast"; "required": false; }; }, { "luxClicked": "luxClicked"; }, never, never, true, never>;
}

declare function isTestEnv(): boolean;

declare class LuxAppService {
    appEl?: HTMLElement;
    appHeaderEl?: HTMLElement;
    appContentEl?: HTMLElement;
    appFooterEl?: HTMLElement;
    resize$: Subject<void>;
    constructor();
    getHeaderWidth(): number;
    getHeaderHeight(): number;
    getContentWidth(): number;
    getContentHeight(): number;
    getFooterWidth(): number;
    getFooterHeight(): number;
    getAppTop(): number;
    getAppLeft(): number;
    getAppBottom(): number;
    getAppRight(): number;
    getAppHeight(): number;
    getAppWidth(): number;
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxAppService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxAppService>;
}

declare class LuxPaginatorIntl extends MatPaginatorIntl implements OnDestroy {
    private tService;
    private langSub?;
    constructor();
    private updateLabels;
    /**
     * Deutsche Fassung des Material-Paginators
     * @param page
     * @param pageSize
     * @param length
     */
    private customRangeLabel;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxPaginatorIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxPaginatorIntl>;
}

/**
 * Der LuxStorageService speichert Daten im lokalen Browserstorage.
 * Wenn man beim Speichern (Methode -> setItem) angibt, dass es sich um sensible Daten handelt,
 * können diese einfach über die Methode 'clearSensitiveItems' gelöscht werden.
 */
declare class LuxStorageService implements OnDestroy {
    private readonly postfixSensitive;
    private itemSources;
    constructor();
    ngOnDestroy(): void;
    private onStorageEvent;
    /**
     * Diese Methode liefert den Wert für den übergebenen Schlüssel zurück.
     * @param key - Der eindeutige Schlüssel.
     * @returns Liefert den Wert für den übergebenen Schlüssel zurück.
     */
    getItem(key: string): string | null;
    /**
     * Diese Methode liefert ein Observable zurück, das über alle Änderungen an dem Schlüssel informiert wird.
     * @param key - Der eindeutige Schlüssel.
     * @returns Liefert ein Observable zurück, das über alle Änderungen an dem Schlüssel informiert wird.
     */
    getItemAsObservable(key: string): Observable<string | null>;
    /**
     * Liefert alle Keys im LocalStorage als Array zurück.
     */
    getKeys(): string[];
    /**
     * Liefert die Anzahl der Einträge im LocalStorage zurück.
     */
    get length(): number;
    /**
     * Diese Methode setzt den übergebenen Wert für den Schlüssel. Zusätzlich muss angegeben werden, ob es sich um
     * sensible oder personenbezogene Daten handelt.
     * @param key - Der eindeutige Schlüssel.
     * @param value - Der neue Wert.
     * @param sensitive - Gibt an, ob es sich um sensible oder personenbezogene Daten handelt. Diese können leicht über
     *                    die Methode 'clearSensitiveItems' (z.B. beim Ausloggen) gelöscht werden.
     */
    setItem(key: string, value: string, sensitive: boolean): void;
    /**
     * Diese Methode entfernt den übergebenen Schlüssel.
     * @param key - Der eindeutige Schlüssel.
     */
    removeItem(key: string): void;
    /**
     * Diese Methode löscht alle sensiblen und personenbezogenen Einträge (d.h. alle Items bei denen das Flag 'sensitive'
     * auf true gesetzt wurde).
     */
    clearSensitiveItems(): void;
    /**
     * Diese Methode löscht alle Einträge aus dem Storage.
     */
    clearAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuxStorageService>;
}

declare class LuxUtil {
    static readonly ISO_8601_FULL: RegExp;
    /**
     * Diese Methode wirft einen Fehler, wenn der Wert nicht gesetzt wurde.
     * @param name Ein Name.
     * @param value Ein Wert.
     */
    static assertNonNull(name: string, value: any): void;
    /**
     * Liest aus einem Objekt ein bestimmtes Feld aus.
     * Lässt sich auch über mehrere Unterobjekte verschachteln.
     * Beispiele für propertyNamePath:
     * "value"
     * "unterobjekt1.unterobjekt2.value"
     * @param el
     * @param propertyNamePath
     * @returns any
     */
    static readPropertyValueFromObject(el: any, propertyNamePath: string): any;
    /**
     * Gibt eine von verschiedenen vordefinierten Fehlernachrichten passend zu den
     * vorhandenen Fehlern der übergebenen FormControl zurück.
     * @param tService Der TranslocoService.
     * @param formControl
     * @returns string
     */
    static getErrorMessage(tService: TranslocoService, formControl: FormControl<any>): string;
    /**
     * Prüft, ob der übergebene Wert ein JS-Datum ist.
     * @param value
     * @returns boolean
     */
    static isDate(value: any): boolean;
    /**
     * Diese Methode liefert ein neues Date-Objekt auf Basis des übergebenen Date-Objekts zurück.
     * Das zurückgelieferte Date-Objekt hat denselben Tag, Monat und das Jahr wie das übergebene Date-Objekt,
     * die Stunden, Minuten und Sekunden sind jedoch 0.
     *
     * Sollte der Methode kein Date-Objekt übergeben werden, wird ein neues Date-Objekt erzeugt.
     * @param date oder nichts
     * @returns date
     */
    static newDateWithoutTime(date?: Date): Date;
    /**
     * Zeigt die Validierungsfehler der einzelnen FormControls innerhalb der FormGroup an.
     * Wenn innerhalb der übergebenen FormGroup weitere Formgroups enthalten sind, werden
     * diese ebenfalls validiert.
     * @param formGroup
     */
    static showValidationErrors(formGroup: FormGroup | UntypedFormGroup): void;
    /**
     * Diese Methode scrollt zu der übergebenen Id.
     * @param id Eine Element-Id (z.B. <tag id="myId">...)
     */
    static goTo(id: string): void;
    /**
     * Diese Methode scrollt zum übergebenen Selector.
     * @param selector Ein Selector. Sollte kein Selector übergeben werden, wird nach oben vom Inhaltsbereich gescrollt.
     */
    static goToTop(selector?: string): void;
    /**
     * Diese Methode verhindert, dass ein Event weiterverarbeitet wird.
     * @param event Ein beliebiges Event.
     */
    static stopEventPropagation(event: Event): void;
    static isNumber(toCheck: any): boolean;
    static base64ToArrayBuffer(data: string): Uint8Array<ArrayBuffer>;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die ArrowLeft-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyArrowLeft(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die ArrowUp-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyArrowUp(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die ArrowRight-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyArrowRight(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die ArrowDown-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyArrowDown(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Home-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyHome(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die End-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyEnd(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die PageDown-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyPageDown(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die PageUp-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyPageUp(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Enter-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyEnter(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Tab-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyTab(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Backspace-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyBackspace(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Space-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeySpace(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Delete-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyDelete(event: KeyboardEvent): boolean;
    /**
     * Diese Methode liefert true zurück, wenn es sich um die Escape-Taste handelt, false sonst.
     * @param event Ein beliebiges KeyboardEvent
     */
    static isKeyEscape(event: KeyboardEvent): boolean;
    private static getKey;
    /**
     * Entfernt nicht-ASCII-Chars aus dem String (Beim IE wichtig, dieser fügt gerne versteckte Steuerzeichen
     * in Input-Feldern an die Strings).
     * @param dateString
     */
    static stringWithoutASCIIChars(dateString: string): string;
    /**
     * Diese Methode liefert für die akzeptierten Dateitypen einen I18N-Nachrichtenteil zurück.
     *
     * Beispiel: acceptTypes = .pdf,.txt,.png
     * de = PDF, TXT oder PNG
     * en = PDF, TXT or PNG
     * @param tService Der TranslocoService.
     * @param acceptTypes Die akzeptierten Dateitypen (z.b. .pdf,.txt).
     */
    static getAcceptTypesAsMessagePart(tService: TranslocoService, acceptTypes: string): string;
    /**
     * Diese Methode prüft, ob es sich um einen Asset-Request handelt. Dies ist der Fall wenn in der URL "/assets/" vorkommt.
     * @param request
     */
    static checkIfRequestIsAssetRequest(request: HttpRequest<any>): boolean;
}

declare class LuxTestHelper {
    /**
     * Wichtig: aus fakeAsync-Block heraus aufrufen, da hier tick() genutzt wird.
     * @param input
     * @param value
     * @param fixture
     */
    static setInputValue(input: any, value: any, fixture: any): void;
    /**
     * Wichtig: aus fakeAsync-Block heraus aufrufen, da hier tick() genutzt wird.
     * Wartet asynchrone Aufrufe ab und ruft die ChangeDetection auf
     * @param fixture
     * @param tickDuration
     */
    static wait(fixture: any, tickDuration?: number): void;
    /**
     * Wichtig: aus fakeAsync-Block heraus aufrufen, da hier tick() genutzt wird.
     * Sendet ein Klick-Event ab und wartet dann.
     * @param fixture
     * @param debugElement
     */
    static click(fixture: any, debugElement: DebugElement): void;
    /**
     * Utility to dispatch any event on a Node.
     * @param node
     * @param event
     */
    static dispatchEvent(node: Node | Window, event: Event): Event;
    /**
     * Shorthand to dispatch a fake event on a specified node.
     * @param node
     * @param type
     * @param canBubble
     */
    static dispatchFakeEvent(node: Node | Window, type: string, canBubble?: boolean): Event;
    /**
     * Shorthand to dispatch a keyboard event with a specified key code.
     * @param node
     * @param type
     * @param keyCode
     * @param target
     */
    static dispatchKeyboardEvent(node: Node, type: string, keyCode: number, target?: Element): KeyboardEvent;
    /**
     * Focuses an input and sets its value. Dispatches a fake input event afterwards.
     * @param element
     * @param value
     * @param noInputEvent
     */
    static typeInElement(element: HTMLInputElement, value: string, noInputEvent?: boolean): void;
    /** Steuerung und triggern von Overlays implementieren */
    /**
     * Inserts data into an input field, that has to update asynchronous before calling a callback-function
     * Allows to use RxJs Interval-Timers within the Target-Components.
     * @param text
     * @param fixture
     * @param element
     * @param callback
     */
    static typeInElementAsync(text: string, fixture: ComponentFixture<any>, element: HTMLInputElement, callback: () => void): void;
    /**
     * Dispatches a keydown event from an element.
     * @param type
     * @param keyCode
     * @param target
     * @param key
     */
    static createKeyboardEvent(type: string, keyCode: number, target?: Element, key?: string): any;
    /**
     * Creates a fake event object with any desired event type.
     * @param type
     * @param canBubble
     * @param cancelable
     */
    static createFakeEvent(type: string, canBubble?: boolean, cancelable?: boolean): Event;
    static createDropEvent(files: {
        name: string;
        type: string;
    }[]): DragEvent;
    /**
     * Erstellt ein leeres File-Objekt mit Namen und Typ via Blob-Constructor (um Edge/IE-Fehler zu vermeiden).
     * @param name
     * @param type
     */
    static createFileBrowserSafe(name: string, type: string): File;
}

declare class LuxOverlayHelper {
    private overlayContainer;
    private htmlElement;
    constructor();
    selectAllFromOverlay(query: string): NodeListOf<HTMLElement>;
    selectOneFromOverlay(query: string): HTMLElement;
}

export { APP_DATE_FORMATS_AC, APP_DATE_TIME_FORMATS_AC, DEFAULT_DIALOG_CONF, DEFAULT_DIALOG_PRESET_CONF, LUX_CONSENT_CONFIG, LUX_CONSENT_DIALOG_LAUNCHER, LUX_STEPPER_LARGE_DEFAULT_FIN_BTN_CONF, LUX_STEPPER_LARGE_DEFAULT_NEXT_BTN_CONF, LUX_STEPPER_LARGE_DEFAULT_PREV_BTN_CONF, LUX_STEPPER_LARGE_OVERLAY_DATA, LUX_STEPPER_LARGE_OVERLAY_DEFAULT_CONFIG, LuxAccordionColors, LuxAccordionComponent, LuxActionComponentBaseClass, LuxAlphabeticallySortedPipe, LuxAppContentComponent, LuxAppFooterButtonInfo, LuxAppFooterButtonService, LuxAppFooterComponent, LuxAppFooterFixedService, LuxAppFooterLinkInfo, LuxAppFooterLinkService, LuxAppHeaderAcActionNavComponent, LuxAppHeaderAcActionNavItemComponent, LuxAppHeaderAcActionNavItemCustomComponent, LuxAppHeaderAcComponent, LuxAppHeaderAcNavMenuComponent, LuxAppHeaderAcNavMenuItemComponent, LuxAppHeaderAcSessionTimerComponent, LuxAppHeaderAcSessionTimerService, LuxAppHeaderAcUserMenuComponent, LuxAppHeaderActionNavComponent, LuxAppHeaderActionNavItemComponent, LuxAppHeaderActionNavItemCustomComponent, LuxAppHeaderComponent, LuxAppHeaderRightNavComponent, LuxAppService, LuxAriaBase, LuxAriaDescribedbyDirective, LuxAriaExpandedDirective, LuxAriaHaspopupDirective, LuxAriaHiddenDirective, LuxAriaInvalidDirective, LuxAriaLabelDirective, LuxAriaLabelledbyDirective, LuxAriaRequiredDirective, LuxAriaRoleDirective, LuxAutocompleteAcComponent, LuxAutocompleteErrorStateMatcherAc, LuxAutofocusDirective, LuxBadgeColors, LuxBadgeComponent, LuxBadgeNotificationDirective, LuxBehandlungsOptionenUngueltige, LuxBgAllColors, LuxBreadcrumbComponent, LuxButtonComponent, LuxButtonToggleComponent, LuxCardActionsComponent, LuxCardComponent, LuxCardContentComponent, LuxCardContentExpandedComponent, LuxCardCustomHeaderComponent, LuxCardHeadingComponent, LuxCardInfoComponent, LuxCheckboxAcComponent, LuxCheckboxContainerAcComponent, LuxChipAcComponent, LuxChipAcGroupComponent, LuxChipsAcComponent, LuxComponentsConfigModule, LuxComponentsConfigService, LuxConfigTokenService, LuxConsentDialogComponent, LuxConsentDialogLauncherService, LuxConsentPurpose, LuxConsentService, LuxConsentStorageType, LuxConsoleService, LuxCustomTagIdDirective, LuxDateTimePickerAcAdapter, LuxDatepickerAcAdapter, LuxDatepickerAcComponent, LuxDatepickerAcCustomHeaderComponent, LuxDatetimeOverlayAcComponent, LuxDatetimeOverlayContentAcComponent, LuxDatetimepickerAcComponent, LuxDetailHeaderAcComponent, LuxDetailViewAcComponent, LuxDetailWrapperAcComponent, LuxDialogActionsComponent, LuxDialogContentComponent, LuxDialogPresetComponent, LuxDialogRef, LuxDialogService, LuxDialogStructureComponent, LuxDialogTitleComponent, LuxDividerComponent, LuxErrorPageComponent, LuxErrorService, LuxErrorStoreService, LuxFieldValues, LuxFileCaptureDirective, LuxFileDeleteDialogComponent, LuxFileErrorCause, LuxFileInputAcComponent, LuxFileListComponent, LuxFileProgressComponent, LuxFileRenameDialogComponent, LuxFileReplaceDialogComponent, LuxFileUploadComponent, LuxFilter, LuxFilterFormComponent, LuxFilterFormExtendedComponent, LuxFilterItem, LuxFilterItemDirective, LuxFilterLoadDialogComponent, LuxFilterSaveDialogComponent, LuxFormCheckableBaseClass, LuxFormComponentBase, LuxFormControlWrapperComponent, LuxFormFileBase, LuxFormHintComponent, LuxFormInputBaseClass, LuxFormLabelComponent, LuxFormSelectableBase, LuxHttpErrorComponent, LuxHttpErrorInterceptor, LuxIconColors, LuxIconComponent, LuxIconRegistryService, LuxImageComponent, LuxInfiniteScrollDirective, LuxInputAcComponent, LuxInputAcPrefixComponent, LuxInputAcSuffixComponent, LuxLabelComponent, LuxLangSelectComponent, LuxLinkComponent, LuxLinkPlainComponent, LuxListComponent, LuxListItemComponent, LuxListItemContentComponent, LuxListItemCustomHeaderComponent, LuxListItemIconComponent, LuxLocale, LuxLookupAutocompleteAcComponent, LuxLookupComboboxAcComponent, LuxLookupComponent, LuxLookupErrorStateMatcher, LuxLookupHandlerService, LuxLookupLabelComponent, LuxLookupParameters, LuxLookupService, LuxLookupTableEntry, LuxMasterDetailAcComponent, LuxMasterFooterAcComponent, LuxMasterHeaderAcComponent, LuxMasterHeaderContentAcComponent, LuxMasterListAcComponent, LuxMaxLengthDirective, LuxMediaQueryObserverService, LuxMenuComponent, LuxMenuItemComponent, LuxMenuPanelHeaderComponent, LuxMenuSectionTitleComponent, LuxMenuTriggerComponent, LuxMessageBoxColors, LuxMessageBoxComponent, LuxMessageComponent, LuxNameDirectiveDirective, LuxOverlayHelper, LuxPaginatorIntl, LuxPanelActionComponent, LuxPanelComponent, LuxPanelContentComponent, LuxPanelHeaderDescriptionComponent, LuxPanelHeaderTitleComponent, LuxPopupActionsDirective, LuxPopupComponent, LuxPopupTriggerDirective, LuxProgressColors, LuxProgressComponent, LuxPropertyFromObjectPipe, LuxRadioAcComponent, LuxRelativeTimestampPipe, LuxRenderPropertyPipe, LuxRippleDirective, LuxSelectAcComponent, LuxSideNavComponent, LuxSideNavFooterComponent, LuxSideNavHeaderComponent, LuxSideNavItemComponent, LuxSliderAcComponent, LuxSnackbarColors, LuxSnackbarComponent, LuxSnackbarConfig, LuxSnackbarService, LuxStepComponent, LuxStepContentComponent, LuxStepHeaderComponent, LuxStepperComponent, LuxStepperHelperService, LuxStepperHorizontalComponent, LuxStepperLargeButtonInfo, LuxStepperLargeClickEvent, LuxStepperLargeComponent, LuxStepperLargeMobileOverlayComponent, LuxStepperLargeMobileOverlayRef, LuxStepperLargeMobileOverlayService, LuxStepperLargeSelectionEvent, LuxStepperLargeStepComponent, LuxStepperNavButtonsComponent, LuxStepperParent, LuxStepperVerticalComponent, LuxStorageService, LuxTabComponent, LuxTabIndexDirective, LuxTableColumnComponent, LuxTableColumnContentComponent, LuxTableColumnFooterComponent, LuxTableColumnHeaderComponent, LuxTableComponent, LuxTableDataSource, LuxTableLocalColumnVisibilityStore, LuxTabsComponent, LuxTagIdDirective, LuxTenantLogoComponent, LuxTestHelper, LuxTextareaAcComponent, LuxTextboxColors, LuxTextboxComponent, LuxThemeService, LuxTileAcComponent, LuxTileComponent, LuxToggleAcComponent, LuxTooltipDirective, LuxTourHintComponent, LuxTourHintPresetComponent, LuxTourHintRef, LuxTourHintService, LuxUtil, LuxVetoState, MS_PER_DAY, expansionAnim, isTestEnv, luxFormControlSelektor, luxLookupCompareKeyFn, luxLookupCompareKurzTextFn, luxLookupCompareLangText1Fn, luxLookupCompareLangText2Fn, luxSessionTimerInterceptor, noop, sideNavAnimation, sideNavOverlayAnimation, timeDeltas, timeDeltasRelative, visibilityTrigger };
export type { ICustomCSSConfig, ILuxAppFooterButtonInfo, ILuxAppFooterLinkInfo, ILuxBreadcrumbEntry, ILuxConsentConfig, ILuxConsentDialogLauncher, ILuxDialogAction, ILuxDialogConfig, ILuxDialogPresetConfig, ILuxError, ILuxErrorPageConfig, ILuxFileActionBaseConfig, ILuxFileActionConfig, ILuxFileError, ILuxFileListActionConfig, ILuxFileListDeleteActionConfig, ILuxFileObject, ILuxFileUploadDeleteActionConfig, ILuxFilesActionConfig, ILuxFilesListActionConfig, ILuxMessage, ILuxMessageChangeEvent, ILuxMessageCloseEvent, ILuxStepperButtonConfig, ILuxStepperLargeStep, ILuxTableColumnVisibilityStore, ILuxTableHttpDao, ILuxTableHttpDaoStructure, ILuxTourHintStepConfig, InitializedTourHintConfig, LuxAccordionColor, LuxBadgeColor, LuxBadgeNotificationColor, LuxBadgeNotificationPosition, LuxBadgeNotificationSize, LuxBgAllColor, LuxBgBaseColor, LuxButtonToggleOption, LuxCardActionAlignType, LuxChipsAcOrientation, LuxCompareWithFnType, LuxComponentsConfigParameters, LuxConsentEntry, LuxConsentState, LuxCookieCategory, LuxDateFilterAcFn, LuxDialogDefaultButton, LuxDisplayWithAcFnType, LuxErrorCallbackFnType, LuxFgColor, LuxFilterRenderFnType, LuxIconColor, LuxLookupCompareFn, LuxMessageBoxColor, LuxModeType, LuxPickValueFnType, LuxPopupCloseReason, LuxPopupPosition, LuxProgressColor, LuxProgressModeType, LuxProgressSizeType, LuxProgressType, LuxScrollPosition, LuxSliderAcColor, LuxSliderAcTickInterval, LuxSnackbarColor, LuxStartAcView, LuxStepperLargeClickEventSourceType, LuxStepperLargeMobileOverlayConfig, LuxStepperLargeMobileOverlayData, LuxSvgIcon, LuxTableDoubleClickEventType, LuxTextboxColor, LuxTheme, LuxThemePalette, LuxTogglePosition, LuxValidationErrors, OnCloseListener, ValidatorFnType };