@festo-ui/angular 8.3.0-dev.647 → 8.3.0-dev.664

package/index.d.ts

@@ -1,5 +1,2045 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, OnChanges, AfterViewInit, AfterContentInit, ElementRef, Renderer2, ChangeDetectorRef, SimpleChanges, QueryList, EventEmitter, NgZone, TemplateRef, Type, Injector, OnInit, ViewContainerRef, ViewRef, DestroyRef, PipeTransform } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { RouterLinkActive, Router } from '@angular/router';
+import { OverlayRef, Overlay, ConnectedPosition, GlobalPositionStrategy, ConnectionPositionPair } from '@angular/cdk/overlay';
+import { ComponentType } from '@angular/cdk/portal';
+import * as i1 from '@angular/forms';
+import { ControlValueAccessor, ValidatorFn, AbstractControlOptions, AsyncValidatorFn, FormGroup, FormBuilder } from '@angular/forms';
+import { Swiper } from 'swiper/types';
+import { CdkDragMove } from '@angular/cdk/drag-drop';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import QuillType from 'quill';
+
+declare class FngAccordionItemBodyComponent {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngAccordionItemBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngAccordionItemBodyComponent, "fng-accordion-item-body", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare enum FngAccordionHeaderActions {
+    Toggle = "toggle"
+}
+declare class FngAccordionItemHeaderComponent implements OnDestroy {
+    id: string;
+    private actions;
+    actions$: Observable<FngAccordionHeaderActions>;
+    ngOnDestroy(): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngAccordionItemHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngAccordionItemHeaderComponent, "fng-accordion-item-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FngAccordionItemComponent implements OnChanges, AfterViewInit, AfterContentInit {
+    private elementRef;
+    private renderer;
+    private cd;
+    static nextId: number;
+    componentId: string;
+    expanded: boolean;
+    _linkText: string;
+    get linkText(): string;
+    header: FngAccordionItemHeaderComponent | undefined;
+    body: FngAccordionItemBodyComponent | undefined;
+    id: string;
+    parentId: string;
+    private accordion;
+    private accordionSubscription;
+    private accordionItemHeaderSubscription;
+    private element;
+    private pristine;
+    constructor(elementRef: ElementRef, renderer: Renderer2, cd: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    toggle(): void;
+    collapseItem(): void;
+    expandItem(): void;
+    private handleAction;
+    private subscribeToAccordionActions;
+    private subscribeToAccordionItemHeaderActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngAccordionItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngAccordionItemComponent, "fng-accordion-item", never, {}, {}, ["header", "body"], ["*"], true, never>;
+}
+
+declare enum FngAccordionActions {
+    OpenAll = "openAll",
+    CloseAll = "closeAll"
+}
+declare class FngAccordionComponent implements AfterViewInit, OnDestroy {
+    static nextId: number;
+    readonly componentId: string;
+    private actions;
+    actions$: Observable<FngAccordionActions>;
+    multi: boolean;
+    showMore: string;
+    showLess: string;
+    items: QueryList<FngAccordionItemComponent> | undefined;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    openAll(): void;
+    closeAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngAccordionComponent, "fng-accordion", never, { "multi": { "alias": "fngAccordionKeepItemsOpen"; "required": false; }; "showMore": { "alias": "fngAccordionShowMoreText"; "required": false; }; "showLess": { "alias": "fngAccordionShowLessText"; "required": false; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare class FngAccordionHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngAccordionHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngAccordionHeaderComponent, "fng-accordion-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FngBreadcrumbComponent {
+    useRouterLink: boolean;
+    locations: {
+        label: string;
+        url: string;
+    }[];
+    navigate: EventEmitter<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngBreadcrumbComponent, "fng-breadcrumb", never, { "useRouterLink": { "alias": "useRouterLink"; "required": false; }; "locations": { "alias": "locations"; "required": false; }; }, { "navigate": "navigate"; }, never, never, true, never>;
+}
+
+declare class FngButtonComponent {
+    text: string | undefined;
+    icon: string | undefined;
+    disabled: boolean;
+    primary: boolean;
+    tertiary: boolean;
+    iconOnly: boolean;
+    large: boolean;
+    floating: boolean;
+    fngClick: EventEmitter<any>;
+    content: ElementRef | undefined;
+    onClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngButtonComponent, "fng-button", never, { "text": { "alias": "text"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "primary": { "alias": "primary"; "required": false; }; "tertiary": { "alias": "tertiary"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; "large": { "alias": "large"; "required": false; }; "floating": { "alias": "floating"; "required": false; }; }, { "fngClick": "fngClick"; }, ["content"], ["*"], true, never>;
+}
+
+declare class FngLinkButtonComponent {
+    text: string | undefined;
+    icon: string | undefined;
+    disabled: boolean;
+    iconOnly: boolean;
+    fngClick: EventEmitter<any>;
+    content: ElementRef | undefined;
+    onClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngLinkButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngLinkButtonComponent, "fng-link-button", never, { "text": { "alias": "text"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; }, { "fngClick": "fngClick"; }, ["content"], ["*"], true, never>;
+}
+
+declare class FngChipContainerComponent {
+    large: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngChipContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngChipContainerComponent, "fng-chip-container", never, { "large": { "alias": "large"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare enum ChipType {
+    Choise = "CHOISE",
+    Category = "CATEGORY",
+    Filter = "FILTER",
+    Action = "ACTION",
+    Readonly = "READONLY"
+}
+declare class FngChipComponent {
+    ChipType: typeof ChipType;
+    type: ChipType;
+    selected: boolean;
+    disabled: boolean;
+    icon: string | undefined;
+    large: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngChipComponent, "fng-chip", never, { "type": { "alias": "type"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "large": { "alias": "large"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FngClickOutsideDirective {
+    private elRef;
+    constructor(elRef: ElementRef);
+    clickOutside: EventEmitter<any>;
+    onClick(targetElement: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngClickOutsideDirective, "[fngClickOutside]", never, {}, { "clickOutside": "clickOutside"; }, never, never, true, never>;
+}
+
+declare enum FngPaginationType {
+    Numeric = "NUMERIC",
+    Dots = "DOTS"
+}
+declare class FngPaginationComponent {
+    PaginationType: typeof FngPaginationType;
+    type: FngPaginationType;
+    pageCurrent: number;
+    set pageMax(value: number);
+    get pageMax(): number;
+    changePage: EventEmitter<number>;
+    innerPageMax: number;
+    dotArray: number[];
+    onBtnDown(): void;
+    onBtnUp(): void;
+    onDotClick(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngPaginationComponent, "fng-pagination", never, { "type": { "alias": "type"; "required": false; }; "pageCurrent": { "alias": "pageCurrent"; "required": false; }; "pageMax": { "alias": "pageMax"; "required": false; }; }, { "changePage": "changePage"; }, never, never, true, never>;
+}
+
+declare class FngMobileFlyoutItemComponent implements OnChanges {
+    rla: RouterLinkActive | null;
+    icon: string;
+    pageLink: string;
+    lastElement: boolean;
+    onNavigateCallback: ((pageName: string) => void) | undefined;
+    constructor(rla: RouterLinkActive | null);
+    ngOnChanges(_: SimpleChanges): void;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngMobileFlyoutItemComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngMobileFlyoutItemComponent, "fng-mobile-flyout-item", never, { "icon": { "alias": "icon"; "required": false; }; "pageLink": { "alias": "pageLink"; "required": false; }; "lastElement": { "alias": "lastElement"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FngMobileFlyoutPageComponent implements AfterContentInit, OnDestroy {
+    itemComponents: QueryList<FngMobileFlyoutItemComponent>;
+    name: string;
+    back: string;
+    isfirstelement: boolean;
+    visible: boolean;
+    onNavigateCallback: ((pageName: string) => void) | undefined;
+    private complete;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onNavigate(pageName: string): void;
+    onBack(): void;
+    private initItemComponents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngMobileFlyoutPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngMobileFlyoutPageComponent, "fng-mobile-flyout-page", never, { "name": { "alias": "name"; "required": false; }; "back": { "alias": "back"; "required": false; }; }, {}, ["itemComponents"], ["*"], true, never>;
+}
+
+declare class FngMobileFlyoutComponent implements AfterContentInit, OnDestroy {
+    flyoutOpenChange: EventEmitter<boolean>;
+    pageComponents: QueryList<FngMobileFlyoutPageComponent>;
+    isOpen: boolean;
+    private complete;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onNavigate(pageName: string): void;
+    toggle(): void;
+    onClickOutside(): void;
+    private initPageComponents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngMobileFlyoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngMobileFlyoutComponent, "fng-mobile-flyout", never, {}, { "flyoutOpenChange": "flyoutOpenChange"; }, ["pageComponents"], ["*"], true, never>;
+}
+
+declare class FngLoadingIndicatorComponent {
+    size: 'large' | 'medium' | 'small';
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngLoadingIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngLoadingIndicatorComponent, "fng-loading-indicator", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FngTabPaneComponent implements OnChanges {
+    static nextId: number;
+    id: string | undefined;
+    name: string | undefined;
+    icon: string | undefined;
+    active: boolean | undefined;
+    isVisible: boolean | undefined;
+    disabled: boolean;
+    tabId: string | undefined;
+    tabPaneId: string;
+    private changesSubject;
+    changes$: rxjs.Observable<boolean>;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTabPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTabPaneComponent, "fng-tab-pane", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "active": { "alias": "active"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface FngTab {
+    name: string;
+    paneId: string | null;
+    active?: boolean;
+    icon?: string | null;
+    disabled?: boolean;
+}
+type FngTabItemAppearance = 'fill' | 'equal' | 'default';
+type FngTabViewType = 'legacy' | 'responsive';
+interface FngTabsConfiguration {
+    tabBar?: {
+        fullWidth?: boolean;
+    };
+    tabItems?: {
+        appearance: FngTabItemAppearance;
+    };
+}
+interface FngTabDimensions {
+    rootLeft: number;
+    rootRight: number;
+    contentLeft: number;
+    contentRight: number;
+}
+interface FngTabScrollAnimation {
+    finalScrollPosition: number;
+    scrollDelta: number;
+}
+interface FngTabScrollHorizontalEdges {
+    left: number;
+    right: number;
+}
+interface FngBeforeTabChangeEvent {
+    ok: () => void;
+    cancel: () => void;
+}
+declare class FngTabsComponent implements AfterContentInit, AfterViewInit, OnDestroy {
+    private elRef;
+    private document;
+    private renderer;
+    private cd;
+    static nextId: number;
+    viewType: FngTabViewType;
+    showDivider: boolean;
+    config: FngTabsConfiguration | null;
+    fngBeforeTabChange: EventEmitter<FngBeforeTabChangeEvent>;
+    fngTabChange: EventEmitter<{
+        previous: string;
+        current: string;
+    }>;
+    panes: QueryList<FngTabPaneComponent> | undefined;
+    scroller: ElementRef | undefined;
+    scrollAera: ElementRef | undefined;
+    scrollContent: ElementRef | undefined;
+    componentId: string;
+    tabs: FngTab[];
+    useCompactDensity: boolean;
+    private activeTab;
+    private elemScroller;
+    private elemScrollArea;
+    private elemScrollContent;
+    private readonly injectedWindow;
+    private resizeObserver;
+    private complete;
+    constructor(elRef: ElementRef, document: Document, renderer: Renderer2, cd: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    showTabPane(id: string | null): void;
+    handleTabScroll(event: any, index: number): void;
+    private initTabs;
+    private initActiveTab;
+    private handleTabPaneChanges;
+    private scrollTo;
+    private scrollIntoView;
+    private incrementScroll;
+    private animate;
+    private stopScrollAnimation;
+    private getAnimatingScrollPosition;
+    private getIncrementScrollOperation;
+    private clampScrollValue;
+    private calculateScrollEdges;
+    private computeDimensions;
+    private calculateScrollIncrement;
+    private indexIsInRange;
+    private getScrollPosition;
+    private calculateCurrentTranslateX;
+    private getScrollContentStyleValue;
+    private setScrollContentStyleProperty;
+    private findAdjacentTabIndexClosestToEdge;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTabsComponent, "fng-tabs", never, { "viewType": { "alias": "fngTabsViewType"; "required": false; }; "showDivider": { "alias": "fngTabsUseBottomDivider"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "fngBeforeTabChange": "fngBeforeTabChange"; "fngTabChange": "fngTabChange"; }, ["panes"], ["*"], true, never>;
+}
+
+declare class FngSearchSuggestion {
+    /**
+     * a html-string. e.g.: '<strong> hello </strong>'
+     */
+    template: string;
+    /**
+     * This Value will be used as new query when the user selects the suggestion.
+     */
+    value: string;
+    /**
+     * Creates a basic Suggestion from a string. The first query match is highlighted by bold tags.
+     * @param suggestionString The suggested string (should contain the whole query)
+     * @param query The current query. This string will be highlighted.
+     * @returns a html-string.
+     */
+    static basicSuggestion(suggestionString: string, query: string): FngSearchSuggestion;
+}
 /**
- * Generated bundle index. Do not edit.
+ * A custom form element for search inputs.
  */
-/// <amd-module name="@festo-ui/angular" />
-export * from './public-api';
+declare class FngSearchInputComponent {
+    inputRef: ElementRef<HTMLInputElement>;
+    /**
+     * the querrry was changed, update the suggetion list
+     */
+    readonly fngChange: EventEmitter<string>;
+    /**
+     * Start search on this event
+     */
+    readonly fngSearch: EventEmitter<string>;
+    /**
+     * The search input label.
+     */
+    label: string;
+    /**
+     * When true the control's disabled attribute is set
+     * and it gets addeed the .disabled css class.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected innerDisabled: boolean;
+    innerValue: string;
+    /**
+     * The getter for value.
+     */
+    get value(): string;
+    /**
+     * The setter for value.
+     */
+    set value(value: string);
+    /**
+     * The list of suggestions
+     */
+    set suggestions(value: FngSearchSuggestion[]);
+    /**
+     * The list of suggestions capped by 10 entries
+     */
+    get cappedSuggestions(): FngSearchSuggestion[];
+    innerSuggestions: FngSearchSuggestion[];
+    hideSuggestionList: boolean;
+    selectedSuggestionIndex: number;
+    keyhandler(event: KeyboardEvent): void;
+    onClickOutside(): void;
+    onFocus(): void;
+    onInput(event: any): void;
+    onSearch(event: any): void;
+    onSuggestionClick(suggestion: FngSearchSuggestion): void;
+    clearQuery(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSearchInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSearchInputComponent, "fng-search-input", never, { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; }, { "fngChange": "fngChange"; "fngSearch": "fngSearch"; }, never, never, true, never>;
+}
+
+interface FngSnackbarConfig {
+    type?: 'info' | 'warning' | 'error';
+    variant?: 'a' | 'b' | 'c';
+    darkBackground?: boolean;
+    showClose?: boolean;
+    action?: string;
+    disappearAfter?: number;
+    closeOnAction?: boolean;
+}
+interface FngSnackbarData extends FngSnackbarConfig {
+    text: string;
+}
+
+declare class FngSnackbarContainerComponent {
+    config: FngSnackbarConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSnackbarContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSnackbarContainerComponent, "fng-snackbar-container", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FngStepHorizontalComponent {
+    isActive: boolean;
+    title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngStepHorizontalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngStepHorizontalComponent, "fng-step-horizontal", never, { "isActive": { "alias": "isActive"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FngStepperHorizontalComponent implements AfterContentInit, OnChanges {
+    stepComponents: QueryList<FngStepHorizontalComponent>;
+    stepIndex: number;
+    stepIndexChange: EventEmitter<number>;
+    ngOnChanges(): void;
+    updateStepComponents(): void;
+    ngAfterContentInit(): void;
+    onStepClick(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngStepperHorizontalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngStepperHorizontalComponent, "fng-stepper-horizontal", never, { "stepIndex": { "alias": "stepIndex"; "required": false; }; }, { "stepIndexChange": "stepIndexChange"; }, ["stepComponents"], ["*"], true, never>;
+}
+
+declare class FngStepVerticalComponent implements AfterViewInit {
+    stepContent?: ElementRef;
+    stepContentContainer?: ElementRef;
+    index: number;
+    title: string;
+    isDone: boolean;
+    isLastElement: boolean;
+    set isActive(value: boolean);
+    get isActive(): boolean;
+    _isActive: boolean;
+    onStepClickCallback: (i: number) => void;
+    updateHeight(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngStepVerticalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngStepVerticalComponent, "fng-step-vertical", never, { "index": { "alias": "index"; "required": false; }; "title": { "alias": "title"; "required": false; }; "isDone": { "alias": "isDone"; "required": false; }; "isLastElement": { "alias": "isLastElement"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FngStepperVerticalComponent implements AfterContentInit, OnChanges {
+    stepComponents: QueryList<FngStepVerticalComponent>;
+    stepIndex: number;
+    stepIndexChange: EventEmitter<number>;
+    ngOnChanges(): void;
+    updateStepComponents(): void;
+    ngAfterContentInit(): void;
+    onStepClick(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngStepperVerticalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngStepperVerticalComponent, "fng-stepper-vertical", never, { "stepIndex": { "alias": "stepIndex"; "required": false; }; }, { "stepIndexChange": "stepIndexChange"; }, ["stepComponents"], ["*"], true, never>;
+}
+
+interface FngTableColumnOrder {
+    orderBy?: string;
+    ascending: boolean;
+}
+declare class FngTableHeaderCellDirective {
+    order: FngTableColumnOrder | undefined;
+    fngTh: string | undefined;
+    changeOrder: EventEmitter<string>;
+    abbr: string | undefined;
+    colspan: number | undefined;
+    headers: string | undefined;
+    rowspan: number | undefined;
+    scope: string | undefined;
+    get active(): boolean;
+    get orderDescending(): boolean;
+    onChangeOrder(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTableHeaderCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngTableHeaderCellDirective, "[fngTh]", never, { "order": { "alias": "order"; "required": false; }; "fngTh": { "alias": "fngTh"; "required": false; }; "abbr": { "alias": "abbr"; "required": false; }; "colspan": { "alias": "colspan"; "required": false; }; "headers": { "alias": "headers"; "required": false; }; "rowspan": { "alias": "rowspan"; "required": false; }; "scope": { "alias": "scope"; "required": false; }; }, { "changeOrder": "changeOrder"; }, never, never, true, never>;
+}
+
+interface FngScrollableAware extends AfterViewInit {
+    scrollableViewReady: boolean;
+}
+declare class FngScrollableDirective implements OnChanges, OnDestroy {
+    private el;
+    private ngZone;
+    private renderer;
+    scrollbarMinSize: number;
+    viewReady: boolean;
+    private sb;
+    private isScrolling;
+    private resizeObserver;
+    constructor(el: ElementRef, ngZone: NgZone, renderer: Renderer2);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private initScrollbar;
+    private initResizeObserver;
+    private updateMaxWidth;
+    private delay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngScrollableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngScrollableDirective, "[fngScrollable]", never, { "scrollbarMinSize": { "alias": "fngScrollableScrollbarMinSize"; "required": false; }; "viewReady": { "alias": "fngScrollableViewReady"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FngProgressComponent {
+    progress: number;
+    error: boolean;
+    background: 'white' | 'background' | 'black';
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngProgressComponent, "fng-progress", never, { "progress": { "alias": "progress"; "required": false; }; "error": { "alias": "error"; "required": false; }; "background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface FngPopoverParams<T> {
+    origin?: HTMLElement;
+    content?: FngPopoverContent;
+    options?: FngPopoverOptions;
+    data: T;
+}
+type FngPopoverTypes = 'tooltip' | 'menu' | 'legend' | 'content';
+type FngPopoverPosition = 'top' | 'bottom' | 'right' | 'left';
+interface FngPopoverOptions {
+    type: FngPopoverTypes;
+    width?: string | number;
+    height?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+    minWidth?: string | number;
+    minHeight?: string | number;
+    hasBackdrop?: boolean;
+    backdropClass?: string;
+    panelClass?: string;
+    positions?: FngPopoverPosition[] | undefined;
+    scrollStrategy?: FngScrollStrategy;
+}
+type FngScrollStrategy = 'noop' | 'close' | 'block';
+interface FngPopoverCloseEvent<T = any> {
+    type: 'backdropClick' | 'close';
+    data: T | undefined;
+}
+declare enum FngPopoverContentTypes {
+    Template = "template",
+    Component = "component",
+    Text = "text"
+}
+type FngPopoverContent = TemplateRef<any> | Type<any> | string;
+interface FngPopoverMenu<T = any> {
+    text: string;
+    icon: string;
+    action: string;
+    data?: T;
+}
+interface FngPopoverMenuAction<T = any> {
+    action: string;
+    payload: T;
+}
+interface FngPopoverMenuActionAware<T = any> {
+    onMenuAction(event: FngPopoverMenuAction<T>): void;
+}
+
+declare class PopoverRef<T = any> {
+    overlay: OverlayRef;
+    content: FngPopoverContent | undefined;
+    data: T;
+    private afterClosed;
+    afterClosed$: rxjs.Observable<FngPopoverCloseEvent<T>>;
+    constructor(overlay: OverlayRef, content: FngPopoverContent | undefined, data: T);
+    close(data?: T): void;
+    private _close;
+}
+
+declare class FngPopoverService {
+    private overlay;
+    private injector;
+    readonly options: FngPopoverOptions;
+    get defaultOptions(): FngPopoverOptions;
+    constructor(overlay: Overlay, injector: Injector);
+    open<T>({ origin, content, data, options }: FngPopoverParams<T>): PopoverRef<T>;
+    private getOverlayConfig;
+    private getScrollStrategy;
+    private getOverlayPosition;
+    private createInjector;
+    private getDefaultPositions;
+    private getPositions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPopoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FngPopoverService>;
+}
+
+interface FngPopoverContentOptions {
+    positions?: FngPopoverPosition[];
+    maxWidth?: string | number;
+    minHeight?: string | number;
+}
+interface FngPopoverContentActions {
+    close: () => void;
+}
+declare class FngPopoverContentComponent implements AfterViewInit, OnDestroy {
+    private popoverService;
+    options: FngPopoverContentOptions;
+    close: EventEmitter<FngPopoverCloseEvent>;
+    actions: EventEmitter<FngPopoverContentActions>;
+    templateRef: TemplateRef<any>;
+    contentRef: ElementRef | undefined;
+    showDefault: boolean;
+    offScreen: boolean;
+    height: number;
+    width: number;
+    private closeSub;
+    private popoverRef;
+    constructor(popoverService: FngPopoverService);
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    show(origin: HTMLElement): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPopoverContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngPopoverContentComponent, "fng-popover-content", never, { "options": { "alias": "options"; "required": false; }; }, { "close": "close"; "actions": "actions"; }, never, ["*"], true, never>;
+}
+
+declare class FngLegendDirective implements OnInit {
+    private elmenetRef;
+    ref: FngPopoverContentComponent | undefined;
+    private origin;
+    constructor(elmenetRef: ElementRef);
+    ngOnInit(): void;
+    show(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngLegendDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngLegendDirective, "[fngLegend]", never, {}, {}, ["ref"], never, true, never>;
+}
+
+declare class FngPopoverComponent implements OnInit {
+    private popoverRef;
+    type: FngPopoverContentTypes | null;
+    content: any;
+    context: any;
+    constructor(popoverRef: PopoverRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngPopoverComponent, "fng-popover", never, {}, {}, never, never, true, never>;
+}
+
+declare class FngPopoverContentDirective implements OnInit {
+    private elmenetRef;
+    component: FngPopoverContentComponent | undefined;
+    private origin;
+    constructor(elmenetRef: ElementRef);
+    ngOnInit(): void;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPopoverContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngPopoverContentDirective, "[fngPopoverContent]", never, {}, {}, ["component"], never, true, never>;
+}
+
+interface FngPopoverMenuOptions {
+    positions?: FngPopoverPosition[];
+}
+declare class FngPopoverMenuComponent {
+    private popoverService;
+    icon: string;
+    menu: FngPopoverMenu[];
+    options: FngPopoverMenuOptions;
+    menuAction: EventEmitter<FngPopoverMenuAction>;
+    menuTpl: TemplateRef<any> | undefined;
+    origin: ElementRef | undefined;
+    private popoverRef;
+    private itemHeight;
+    constructor(popoverService: FngPopoverService);
+    show(event: Event, content: TemplateRef<any> | undefined, origin: HTMLElement): void;
+    action(action: string, payload: any): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPopoverMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngPopoverMenuComponent, "fng-popover-menu", never, { "icon": { "alias": "icon"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "menuAction": "menuAction"; }, never, never, true, never>;
+}
+
+interface FngTooltipOptions {
+    /**
+     * @deprecated
+     * Direct number input of maximum width of the tooltip is not supported anymore.
+     * Use the `customClass` option instead and style the tooltip with CSS.
+     * This option is kept for backward compatibility.
+     */
+    maxWidth?: string | number;
+    delay?: number;
+    customClass?: string;
+}
+declare class FngTooltipDirective implements OnChanges, OnDestroy {
+    private elmenetRef;
+    private popoverService;
+    text: string;
+    isVisible: boolean;
+    positions: FngPopoverPosition[];
+    options: FngTooltipOptions;
+    private origin;
+    private popoverRef;
+    private innerIsVisible;
+    private timeoutHandle;
+    constructor(elmenetRef: ElementRef, popoverService: FngPopoverService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    show(): void;
+    hide(): void;
+    private open;
+    private close;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngTooltipDirective, "[fngTooltip]", never, { "text": { "alias": "fngTooltip"; "required": false; }; "isVisible": { "alias": "fngTooltipVisible"; "required": false; }; "positions": { "alias": "fngTooltipPositions"; "required": false; }; "options": { "alias": "fngTooltipOptions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface FngPopoverLegendOptions {
+    maxWidth?: string | number;
+}
+interface FngLegendItem {
+    name: string;
+    text: string;
+}
+declare class FngLegendComponent {
+    private popoverService;
+    items: FngLegendItem[];
+    options: FngPopoverLegendOptions;
+    templateRef: TemplateRef<any> | undefined;
+    private popoverRef;
+    constructor(popoverService: FngPopoverService);
+    show(origin: HTMLElement): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngLegendComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngLegendComponent, "fng-legend", never, { "items": { "alias": "items"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Every sidebar instance has its unique instanceID.
+ * When a sidebar is opened, this ID is the next currentsInstanceID.
+ * Every instance with an other ID will be closed then.
+ *
+ * usage: <fng-sidebar-overlay [(open)]="sidebarOpen" fngNavbarMargin> ... </fng-details-sidebar>
+ */
+declare class FngSidebarOverlayComponent {
+    static currentsInstanceID$: BehaviorSubject<number>;
+    private instanceID;
+    private internalOpen;
+    get fngNavbarMargin(): boolean;
+    set fngNavbarMargin(value: boolean | '');
+    internalNavbarMargin: boolean;
+    set open(value: boolean | '');
+    get open(): boolean;
+    openChange: EventEmitter<boolean>;
+    constructor();
+    closeSidebar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSidebarOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSidebarOverlayComponent, "fng-sidebar-overlay", never, { "fngNavbarMargin": { "alias": "fngNavbarMargin"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+}
+
+declare class FngBottomSheetComponent {
+    hasBackdrop: boolean;
+    isExpanded: boolean;
+    hideCloseIcon: boolean;
+    expandFrom: 'bottom' | 'center';
+    close: EventEmitter<void>;
+    isOpen: boolean;
+    get isExpandedState(): boolean;
+    isClosing: boolean;
+    private startY;
+    private currentY;
+    private swiping;
+    ngOnInit(): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchMove(event: TouchEvent): void;
+    onTouchEnd(): void;
+    toggleExpand(): void;
+    closeBottomSheet(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngBottomSheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngBottomSheetComponent, "fng-bottom-sheet", never, { "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "hideCloseIcon": { "alias": "hideCloseIcon"; "required": false; }; "expandFrom": { "alias": "expandFrom"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}
+
+type ConnectedPositionName = 'topStart' | 'topCenter' | 'topEnd' | 'bottomStart' | 'bottomCenter' | 'bottomEnd' | 'startTop' | 'startCenter' | 'startBottom' | 'endTop' | 'endCenter' | 'endBottom';
+declare const POSITION_MAP: Record<ConnectedPositionName, ConnectedPosition>;
+declare const ALL_POSITIONS: ConnectedPosition[];
+declare class FngOverlayOutletDirective implements OnDestroy {
+    private readonly host;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly injector;
+    private overlayRef?;
+    private portalInstance?;
+    private positionSubscription?;
+    /**
+     * content for the overlay. supply either a templateref (preferred for arbitrary html)
+     * or a component type (will be created via componentportal).
+     *
+     * example (templateref): [fngOverlayOutlet]="tplref"
+     * example (component):   [fngOverlayOutlet]="youroverlaycomponent"
+     */
+    content: TemplateRef<any> | Type<any>;
+    /** optional context when using templateref content. */
+    fngOverlayContext: Record<string, any> | null;
+    /** css class(es) to apply to the overlay panel. */
+    fngOverlayPanelClass: string | string[] | undefined;
+    /** whether the overlay should have a backdrop. defaults to true. */
+    fngOverlayHasBackdrop: boolean;
+    /** backdrop class; defaults to a transparent clickable backdrop. */
+    fngOverlayBackdropClass: string;
+    /** close the overlay when the backdrop is clicked (if there is one). */
+    fngOverlayCloseOnBackdropClick: boolean;
+    /** close the overlay when pressing escape. */
+    fngOverlayCloseOnEscape: boolean;
+    /** optional x/y offsets applied to every position. */
+    fngOverlayOffsetX: number;
+    fngOverlayOffsetY: number;
+    /**
+     * choose positions by name, or omit to use all_positions fallback order.
+     * example: [fngOverlayPositions]="['topEnd','topStart']"
+     */
+    fngOverlayPositions?: ConnectedPositionName[];
+    /**
+     * if you want a different origin element than the host (rare), pass an htmlelement here.
+     */
+    fngOverlayOrigin?: HTMLElement | ElementRef<HTMLElement> | null;
+    /** emits when the overlay is closed */
+    fngOverlayClosed: EventEmitter<void>;
+    _onHostClick(evt: MouseEvent): void;
+    readonly cssClass = true;
+    constructor(host: ElementRef<HTMLElement>);
+    ngOnDestroy(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    private getPositionClass;
+    private createOverlay;
+    private createPortalFromContent;
+    private bindOverlayLifecycle;
+    private resolveOriginElement;
+    private resolvePositions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngOverlayOutletDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngOverlayOutletDirective, "[fngOverlayOutlet]", never, { "content": { "alias": "fngOverlayOutlet"; "required": false; }; "fngOverlayContext": { "alias": "fngOverlayContext"; "required": false; }; "fngOverlayPanelClass": { "alias": "fngOverlayPanelClass"; "required": false; }; "fngOverlayHasBackdrop": { "alias": "fngOverlayHasBackdrop"; "required": false; }; "fngOverlayBackdropClass": { "alias": "fngOverlayBackdropClass"; "required": false; }; "fngOverlayCloseOnBackdropClick": { "alias": "fngOverlayCloseOnBackdropClick"; "required": false; }; "fngOverlayCloseOnEscape": { "alias": "fngOverlayCloseOnEscape"; "required": false; }; "fngOverlayOffsetX": { "alias": "fngOverlayOffsetX"; "required": false; }; "fngOverlayOffsetY": { "alias": "fngOverlayOffsetY"; "required": false; }; "fngOverlayPositions": { "alias": "fngOverlayPositions"; "required": false; }; "fngOverlayOrigin": { "alias": "fngOverlayOrigin"; "required": false; }; }, { "fngOverlayClosed": "fngOverlayClosed"; }, never, never, true, never>;
+}
+
+declare class FngOverlayContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngOverlayContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngOverlayContentComponent, "fng-overlay-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class FestoAngularComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FestoAngularComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FestoAngularComponentsModule, never, [typeof FngClickOutsideDirective, typeof FngPaginationComponent, typeof FngMobileFlyoutPageComponent, typeof FngMobileFlyoutItemComponent, typeof FngMobileFlyoutComponent, typeof FngLoadingIndicatorComponent, typeof FngChipComponent, typeof FngChipContainerComponent, typeof FngTabsComponent, typeof FngTabPaneComponent, typeof FngBreadcrumbComponent, typeof FngAccordionComponent, typeof FngAccordionHeaderComponent, typeof FngAccordionItemComponent, typeof FngAccordionItemBodyComponent, typeof FngAccordionItemHeaderComponent, typeof FngButtonComponent, typeof FngLinkButtonComponent, typeof FngSearchInputComponent, typeof FngSnackbarContainerComponent, typeof FngStepHorizontalComponent, typeof FngStepperHorizontalComponent, typeof FngStepperVerticalComponent, typeof FngStepVerticalComponent, typeof FngTableHeaderCellDirective, typeof FngScrollableDirective, typeof FngProgressComponent, typeof FngLegendDirective, typeof FngPopoverComponent, typeof FngPopoverContentDirective, typeof FngPopoverContentComponent, typeof FngPopoverMenuComponent, typeof FngTooltipDirective, typeof FngLegendDirective, typeof FngLegendComponent, typeof FngSidebarOverlayComponent, typeof FngBottomSheetComponent, typeof FngOverlayOutletDirective, typeof FngOverlayContentComponent], [typeof FngClickOutsideDirective, typeof FngBreadcrumbComponent, typeof FngAccordionComponent, typeof FngAccordionHeaderComponent, typeof FngAccordionItemComponent, typeof FngAccordionItemBodyComponent, typeof FngAccordionItemHeaderComponent, typeof FngButtonComponent, typeof FngLinkButtonComponent, typeof FngChipContainerComponent, typeof FngChipComponent, typeof FngLoadingIndicatorComponent, typeof FngMobileFlyoutComponent, typeof FngMobileFlyoutItemComponent, typeof FngMobileFlyoutPageComponent, typeof FngPaginationComponent, typeof FngSearchInputComponent, typeof FngSnackbarContainerComponent, typeof FngStepHorizontalComponent, typeof FngStepperHorizontalComponent, typeof FngStepperVerticalComponent, typeof FngStepVerticalComponent, typeof FngTableHeaderCellDirective, typeof FngScrollableDirective, typeof FngProgressComponent, typeof FngTabsComponent, typeof FngTabPaneComponent, typeof FngLegendDirective, typeof FngPopoverComponent, typeof FngPopoverContentDirective, typeof FngPopoverContentComponent, typeof FngPopoverMenuComponent, typeof FngTooltipDirective, typeof FngLegendDirective, typeof FngLegendComponent, typeof FngSidebarOverlayComponent, typeof FngBottomSheetComponent, typeof FngOverlayOutletDirective, typeof FngOverlayContentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FestoAngularComponentsModule>;
+}
+
+type FngSnackDescription = {
+    data: FngSnackbarData;
+    actionCallback?: () => void;
+    closeCallback?: () => void;
+    resolve: (value: unknown) => void;
+};
+declare class FngSnackbarService {
+    snacks$: Observable<FngSnackDescription>;
+    private snacks;
+    constructor();
+    snack(data: FngSnackbarData, actionCallback?: () => void, closeCallback?: () => void): Promise<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSnackbarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FngSnackbarService>;
+}
+
+declare class FngSnackbarContainerDirective implements OnDestroy {
+    private viewContainerRef;
+    private snackbarService;
+    fngSnackbarContainer: FngSnackbarConfig;
+    private snacks;
+    private snacksSub;
+    constructor(viewContainerRef: ViewContainerRef, snackbarService: FngSnackbarService);
+    ngOnDestroy(): void;
+    private push;
+    private remove;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSnackbarContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngSnackbarContainerDirective, "[fngSnackbarContainer]", never, { "fngSnackbarContainer": { "alias": "fngSnackbarContainer"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FngSnackbarComponent implements AfterViewInit, OnDestroy {
+    data: FngSnackbarData | undefined | null;
+    close: EventEmitter<any>;
+    action: EventEmitter<any>;
+    blockDisplay: string;
+    animationState: 'init' | 'first' | 'fadeIn';
+    private timeout;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onAction(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSnackbarComponent, "fng-snackbar", never, { "data": { "alias": "data"; "required": false; }; }, { "close": "close"; "action": "action"; }, never, never, true, never>;
+}
+
+declare class FestoAngularSnackbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FestoAngularSnackbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FestoAngularSnackbarModule, never, [typeof FngSnackbarComponent, typeof FngSnackbarContainerDirective, typeof FngSnackbarContainerComponent], [typeof FngSnackbarContainerComponent, typeof FngSnackbarContainerDirective, typeof FngSnackbarContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FestoAngularSnackbarModule>;
+}
+
+type ModalUserAction = 'ok' | 'cancel' | 'close' | 'backdrop' | 'navigated';
+interface Modal<TData, TResult> extends Partial<OnChanges> {
+    data: TData;
+    close: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    ok: EventEmitter<TResult>;
+}
+interface ModalOptions {
+    hasBackdrop?: boolean;
+    shouldCloseOnBackdrop?: boolean;
+    backdropClass?: string;
+    positionStrategy?: GlobalPositionStrategy;
+    overlayClass?: string;
+    closeOnNavigation?: boolean;
+}
+interface ModalResult<TResult> {
+    userAction: ModalUserAction;
+    result?: TResult;
+}
+
+interface FngAlertData {
+    title: string;
+    subtitle?: string;
+    body: string;
+    alertType: 'info' | 'warning' | 'error';
+    cancel?: string;
+    ok?: string;
+    strong?: boolean;
+}
+declare class FngAlertComponent implements AfterViewInit, Modal<FngAlertData, any> {
+    data: FngAlertData;
+    close: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    ok: EventEmitter<any>;
+    closeBtn: ElementRef | undefined;
+    onKeyUp(event: KeyboardEvent): void;
+    ngAfterViewInit(): void;
+    onClose(): void;
+    onOk(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngAlertComponent, "fng-alert", never, { "data": { "alias": "data"; "required": false; }; }, { "close": "close"; "cancel": "cancel"; "ok": "ok"; }, never, never, true, never>;
+}
+
+interface FngConfirmData {
+    title: string;
+    subtitle?: string;
+    body: string;
+    cancel?: string;
+    ok?: string;
+    large?: boolean;
+}
+declare class FngConfirmComponent implements AfterViewInit, Modal<FngConfirmData, any> {
+    private cd;
+    data: FngConfirmData;
+    close: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    ok: EventEmitter<any>;
+    closeBtn: ElementRef | undefined;
+    onKeyUp(event: KeyboardEvent): void;
+    constructor(cd: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    onClose(): void;
+    onOk(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngConfirmComponent, "fng-confirm", never, { "data": { "alias": "data"; "required": false; }; }, { "close": "close"; "cancel": "cancel"; "ok": "ok"; }, never, never, true, never>;
+}
+
+/**
+ * A custom form element for text inputs.
+ */
+declare class FngTextInputComponent implements OnInit, ControlValueAccessor {
+    /**
+     * The text input label.
+     */
+    label: string;
+    /**
+     * A string specifying the type of control to render.
+     */
+    get type(): string;
+    set type(value: string);
+    protected innerType: string;
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private innerReadonly;
+    step: number | undefined;
+    min: number | undefined;
+    max: number | undefined;
+    tabindex: number | undefined;
+    placeholder: string | undefined;
+    name: string;
+    /**
+     * When true the control's disabled attribute is set
+     * and it gets addeed the .disabled css class.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected innerDisabled: boolean;
+    /**
+     * The inner value.
+     */
+    innerValue: string;
+    /**
+     * The getter for value.
+     */
+    get value(): string;
+    /**
+     * The setter for value.
+     */
+    set value(value: string);
+    get required(): boolean;
+    set required(value: boolean);
+    protected innerRequired: boolean;
+    /**
+     * Error description when invalid.
+     */
+    error: string;
+    /**
+     * Hint description when valid.
+     */
+    hint: string | undefined;
+    inputElement: ElementRef | undefined;
+    /**
+     * When true the text input has focus.
+     */
+    focused: boolean;
+    /**
+     * Triggered on change.
+     */
+    onChange: ((value: string) => void) | undefined;
+    /**
+     * Triggered on touch.
+     */
+    onTouched: (() => void) | undefined;
+    /**
+     * Called on component initialisation.
+     */
+    ngOnInit(): void;
+    /**
+     * Writes the value.
+     * @param value The value.
+     */
+    writeValue(value: string): void;
+    /**
+     * Registers a function to onChange.
+     * @param fn The registered function.
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Registers a function to onTouched.
+     * @param fn The registered function.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Called when the text input is in focus.
+     */
+    onFocus(): void;
+    /**
+     * Called when the text input blurs.
+     */
+    onBlur(): void;
+    /**
+     * Sets the disabled state.
+     * @param isDisabled When true the control is disabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTextInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTextInputComponent, "fng-text-input", never, { "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "step": { "alias": "step"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "error": { "alias": "error"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; }, {}, never, [".fng-hint", ".fng-error"], true, never>;
+}
+
+interface FngPromptData {
+    title: string;
+    subtitle?: string;
+    label: string;
+    hint?: string;
+    errors?: {
+        [key: string]: string;
+    };
+    cancel?: string;
+    ok?: string;
+    value?: string;
+    placeholder?: string;
+    validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null;
+    asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null;
+}
+declare class FngPromptComponent implements OnInit, AfterViewInit, OnDestroy, Modal<FngPromptData, any> {
+    private formBuilder;
+    data: FngPromptData;
+    close: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    ok: EventEmitter<any>;
+    closeBtn: ElementRef | undefined;
+    inputField: FngTextInputComponent | undefined;
+    form: FormGroup;
+    error: string;
+    get text(): string;
+    get valid(): boolean;
+    private complete;
+    constructor(formBuilder: FormBuilder);
+    onKeyUp(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClose(): void;
+    onOk(): void;
+    onCancel(): void;
+    private handleErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngPromptComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngPromptComponent, "fng-prompt", never, { "data": { "alias": "data"; "required": false; }; }, { "close": "close"; "cancel": "cancel"; "ok": "ok"; }, never, never, true, never>;
+}
+
+declare class FngCustomModalComponent {
+    private _visible;
+    closeOnBackdrop: boolean;
+    large: boolean;
+    set visible(value: boolean);
+    get visible(): boolean;
+    /**
+     * Emits false on close modal by close, cancel, click outside and close by providing value false to visible
+     */
+    visibleChange: EventEmitter<boolean>;
+    header: string;
+    subheader: string | null;
+    acknowledgeLabel: string;
+    acknowledge: EventEmitter<void>;
+    cancelLabel: string;
+    cancel: EventEmitter<void>;
+    close: EventEmitter<void>;
+    closeModal(): void;
+    onClose(): void;
+    onCancel(): void;
+    onAcknowledge(): void;
+    onClickOutside(): void;
+    onClickInside(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngCustomModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngCustomModalComponent, "fng-custom-modal", never, { "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; }; "large": { "alias": "large"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "header": { "alias": "header"; "required": false; }; "subheader": { "alias": "subheader"; "required": false; }; "acknowledgeLabel": { "alias": "acknowledgeLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; }, { "visibleChange": "visibleChange"; "acknowledge": "acknowledge"; "cancel": "cancel"; "close": "close"; }, never, ["*"], true, never>;
+}
+
+declare class FestoAngularModalsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FestoAngularModalsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FestoAngularModalsModule, never, [typeof FngAlertComponent, typeof FngConfirmComponent, typeof FngPromptComponent, typeof FngCustomModalComponent, typeof FngImageGalleryComponent], [typeof FngAlertComponent, typeof FngConfirmComponent, typeof FngPromptComponent, typeof FngCustomModalComponent, typeof FngImageGalleryComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FestoAngularModalsModule>;
+}
+
+interface FngImageDescriptiveContent {
+    title: string;
+    body: string;
+}
+interface FngImageGalleryData {
+    startIndex: number;
+    images: {
+        url: string;
+        alt: string;
+        content?: FngImageDescriptiveContent;
+        containMode?: boolean;
+    }[];
+    thumbnailImages?: {
+        url: string;
+        alt: string;
+        containMode?: boolean;
+    }[];
+    pagination?: boolean;
+    descriptiveContent?: boolean;
+    slideChanged?: (index: number) => void;
+    showScaleButton: boolean;
+}
+declare class FngImageGalleryComponent implements Modal<FngImageGalleryData, any> {
+    private cd;
+    data: FngImageGalleryData;
+    close: EventEmitter<any>;
+    scaleUp: EventEmitter<any>;
+    scaleDown: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    ok: EventEmitter<any>;
+    currentIndex: number;
+    isScaled: boolean;
+    swiperRef: Swiper | undefined;
+    constructor(cd: ChangeDetectorRef);
+    onKeyUp(event: KeyboardEvent): void;
+    onSwiperInit(event: CustomEvent<[Swiper]>): void;
+    onNext(): void;
+    onPrev(): void;
+    onSlideChange(event: CustomEvent<[Swiper]>): void;
+    onClose(): void;
+    onScale(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngImageGalleryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngImageGalleryComponent, "fng-image-gallery", never, { "data": { "alias": "data"; "required": false; }; }, { "close": "close"; "scaleUp": "scaleUp"; "scaleDown": "scaleDown"; "cancel": "cancel"; "ok": "ok"; }, never, never, true, never>;
+}
+
+declare class FngModalService {
+    protected overlay: Overlay;
+    private router;
+    constructor(overlay: Overlay, router: Router);
+    alert(data: FngAlertData, options?: ModalOptions): Promise<ModalResult<any>>;
+    confirm(data: FngConfirmData, options?: ModalOptions): Promise<ModalResult<any>>;
+    prompt(data: FngPromptData, options?: ModalOptions): Promise<ModalResult<any>>;
+    openImageGallery(data: FngImageGalleryData): Promise<ModalResult<any>>;
+    open<TData, TResult, TModal extends Modal<TData, TResult>>(data: TData, modal: ComponentType<TModal>, options: ModalOptions): Promise<ModalResult<TResult>>;
+    private dispose;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FngModalService>;
+}
+
+declare class FngCheckboxComponent implements ControlValueAccessor {
+    private changeDetector;
+    name: string;
+    large: boolean;
+    valid: boolean;
+    labelPosition: 'before' | 'after' | 'below';
+    private innerId;
+    get id(): string;
+    set id(value: string);
+    get inputId(): string;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private isChecked;
+    get disabled(): any;
+    set disabled(value: any);
+    private isDisabled;
+    get indeterminate(): boolean;
+    set indeterminate(value: boolean);
+    private isIndeterminate;
+    value: string;
+    get required(): boolean;
+    set required(value: boolean);
+    private isRequired;
+    readonly indeterminateChange: EventEmitter<boolean>;
+    readonly change: EventEmitter<boolean>;
+    constructor(changeDetector: ChangeDetectorRef);
+    controlValueAccessorChangeFn: (value: any) => void;
+    onTouched: () => any;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInteractionEvent(event: Event): void;
+    onInputClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngCheckboxComponent, "fng-checkbox", never, { "name": { "alias": "name"; "required": false; }; "large": { "alias": "large"; "required": false; }; "valid": { "alias": "valid"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "id": { "alias": "id"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "indeterminateChange": "indeterminateChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A control to display a color.
+ */
+declare class FngColorIndicatorComponent {
+    /**
+     * The label above the color.
+     */
+    label: string;
+    /**
+     * A text next to the color.
+     */
+    text: string;
+    /**
+     * The current color as a string.
+     * Examples: '#ffffff', 'red', 'rgba(1,2,3,0.5)'
+     */
+    color: string;
+    /**
+     * enable an overlay to edit the color.
+     * The editor must be passed as the content of the indicator.
+     */
+    showPopOver: boolean;
+    disabled: boolean;
+    isEditorOpen: boolean;
+    positions: ConnectionPositionPair[];
+    getBorderColor(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngColorIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngColorIndicatorComponent, "fng-color-indicator", never, { "label": { "alias": "label"; "required": false; }; "text": { "alias": "text"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showPopOver": { "alias": "showPopOver"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const PREDEFINED_COLORS: string[];
+/**
+ * A custom form element to pick a color.
+ */
+declare class FngColorPickerComponent implements OnChanges, ControlValueAccessor {
+    baseSize: number;
+    inputType: string;
+    isSelectOpen: boolean;
+    useAlpha: boolean;
+    get alpha(): number;
+    set alpha(value: number);
+    alphaChange: EventEmitter<number>;
+    /**
+     * The current color
+     */
+    get color(): string | null;
+    set color(value: string | null);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * an array with color strings representing the palette.
+     * Example: ['#234567, '#AA00FF']
+     * Pass null to hide palette.
+     */
+    palette: string[];
+    /**
+     * hide the hue and gradient picker and shot the palette only.
+     */
+    paletteOnly: boolean;
+    private innerColor;
+    private innerDisabled;
+    private innerAlpha;
+    hexInputColor: string | null;
+    redInput: number;
+    greenInput: number;
+    blueInput: number;
+    alphaInput: number;
+    hue: number;
+    saturation: number;
+    value: number;
+    hueKnobOffset: number;
+    alphaKnobOffset: number;
+    saturationKnobOffset: number;
+    valueKnobOffset: number;
+    onTouched: () => any;
+    onChange: (color: string | null) => any;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(color: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    updateColorRgb(emitChange: boolean): void;
+    updateColorHsv(): void;
+    onHexBlur(): void;
+    onHexInput(): void;
+    onRgbBlur(): void;
+    onRgbInput(value: number, channel: string): void;
+    onAlphaInput(value: number): void;
+    onGradientClick(event: MouseEvent): void;
+    onGradientDrag(event: CdkDragMove): void;
+    onHueClick(event: MouseEvent): void;
+    onAlphaClick(event: MouseEvent): void;
+    onHueDrag(event: CdkDragMove): void;
+    onAlphaDrag(event: CdkDragMove): void;
+    onRemoveColor(): void;
+    isHexColor(value: string): boolean;
+    getSaturationGradient(): string;
+    updateInputs(hexColor: string | null): void;
+    updateKnobs(): void;
+    onChangeType(type: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngColorPickerComponent, "fng-color-picker", never, { "useAlpha": { "alias": "useAlpha"; "required": false; }; "alpha": { "alias": "alpha"; "required": false; }; "color": { "alias": "color"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "paletteOnly": { "alias": "paletteOnly"; "required": false; }; }, { "alphaChange": "alphaChange"; }, never, never, true, never>;
+}
+
+interface FngDatePickerOptions {
+    maxDate?: Date;
+    minDate?: Date;
+    keepOpenOnDateChange?: boolean;
+}
+declare class FngDatePickerComponent implements ControlValueAccessor {
+    private overlay;
+    private localeDefault;
+    private cd;
+    get value(): Date;
+    set value(date: Date);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected innerDisabled: boolean;
+    hint: string | undefined;
+    error: string | undefined;
+    options: FngDatePickerOptions;
+    /** A locale code for the locale format rules to use. */
+    locale: string | undefined;
+    format: string | undefined;
+    /** The time zone. A time zone offset from GMT (such as `'+0430'`) */
+    timezone: string | undefined;
+    get required(): boolean;
+    set required(value: boolean);
+    protected innerRequired: boolean;
+    connector: ElementRef | undefined;
+    width: string | undefined;
+    display: string;
+    get displayValue(): string;
+    datePickerRef: OverlayRef | undefined;
+    private innerValue;
+    private complete;
+    private datePicker;
+    constructor(overlay: Overlay, localeDefault: string, cd: ChangeDetectorRef);
+    onTouched: (() => any) | undefined;
+    onChange: ((date: Date) => any) | undefined;
+    hide(event: KeyboardEvent): void;
+    onDateChange(date: Date): void;
+    writeValue(date: Date): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    toggle(event: Event): void;
+    private dispose;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngDatePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngDatePickerComponent, "fng-date-picker", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "options": { "alias": "options"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "format": { "alias": "format"; "required": false; }; "timezone": { "alias": "timezone"; "required": false; }; "required": { "alias": "required"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface FngDateRangePickerOptions {
+    maxDate?: Date;
+    minDate?: Date;
+    keepOpenOnDateChange?: boolean;
+}
+declare class FngDateRangePickerComponent implements ControlValueAccessor {
+    private overlay;
+    private localeDefault;
+    private cd;
+    get value(): Date[];
+    set value(dateRange: Date[]);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected innerDisabled: boolean;
+    hint: string | undefined;
+    error: string | undefined;
+    /** A locale code for the locale format rules to use. */
+    locale: string | undefined;
+    format: string | undefined;
+    /** The time zone. A time zone offset from GMT (such as `'+0430'`) */
+    timezone: string | undefined;
+    options: FngDateRangePickerOptions;
+    get required(): boolean;
+    set required(value: boolean);
+    protected innerRequired: boolean;
+    width: string;
+    display: string;
+    fngChange: EventEmitter<any>;
+    change: EventEmitter<any>;
+    connector: ElementRef | undefined;
+    get fromDateDisplayValue(): string | null;
+    get toDateDisplayValue(): string | null;
+    dateRangePickerRef: OverlayRef | undefined;
+    private innerValue;
+    private complete;
+    private datePicker;
+    constructor(overlay: Overlay, localeDefault: string, cd: ChangeDetectorRef);
+    onTouched: (() => any) | undefined;
+    onChange: ((dateRange: Date[]) => any) | undefined;
+    hide(event: KeyboardEvent): void;
+    onDateChange(dateRange: Date[]): void;
+    writeValue(dateRange: Date[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    toggle(event: Event): void;
+    private dispose;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngDateRangePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngDateRangePickerComponent, "fng-date-range-picker", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "format": { "alias": "format"; "required": false; }; "timezone": { "alias": "timezone"; "required": false; }; "options": { "alias": "options"; "required": false; }; "required": { "alias": "required"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "fngChange": "fngChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare class FngTimePickerDropdownComponent implements AfterViewInit {
+    date: Date;
+    showSeconds: boolean;
+    timeFormat: '12' | '24';
+    dateChange: EventEmitter<{
+        reset: boolean;
+        date: Date;
+        close: boolean;
+    }>;
+    hoursInput: ElementRef | undefined;
+    hide(event: KeyboardEvent): void;
+    ngAfterViewInit(): void;
+    onHourUp(): void;
+    onHourDown(): void;
+    onMinuteUp(): void;
+    onMinuteDown(): void;
+    onSecondUp(): void;
+    onSecondDown(): void;
+    onHourChange(event: Event): void;
+    onMinuteChange(event: Event): void;
+    onSecondChange(event: Event): void;
+    onToggleTimeFormat(): void;
+    onDateChange(close: boolean, reset: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTimePickerDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTimePickerDropdownComponent, "fng-time-picker-dropdown", never, { "date": { "alias": "date"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; }, { "dateChange": "dateChange"; }, never, never, true, never>;
+}
+
+interface FngTimePickerOptions {
+    timeFormat?: '12' | '24';
+    showSeconds?: boolean;
+}
+declare class FngTimePickerComponent implements ControlValueAccessor {
+    private overlay;
+    private cd;
+    get value(): Date;
+    set value(date: Date);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    protected innerRequired: boolean;
+    hint: string | undefined;
+    error: string | undefined;
+    options: FngTimePickerOptions | undefined;
+    width: string;
+    display: string;
+    connector: ElementRef | undefined;
+    get timeFormat(): string;
+    timePickerRef: OverlayRef | null;
+    protected innerValue: Date;
+    protected innerDisabled: boolean;
+    private complete;
+    private timePicker;
+    constructor(overlay: Overlay, cd: ChangeDetectorRef);
+    onTouched: (() => void) | undefined;
+    onChange: ((date: Date) => void) | undefined;
+    writeValue(date: Date): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    toggle(event: Event): void;
+    disposeDropdown(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTimePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTimePickerComponent, "fng-time-picker", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "options": { "alias": "options"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type UniqueSelectionDispatcherListener = (id: string, name: string) => void;
+declare class FngUniqueSelectionDispatcher implements OnDestroy {
+    private listeners;
+    /**
+     * Notify other items that selection for the given name has been set.
+     * @param id ID of the item.
+     * @param name Name of the item.
+     */
+    notify(id: string, name?: string): void;
+    /**
+     * Listen for future changes to item selection.
+     * @return Function used to deregister listener
+     */
+    listen(listener: UniqueSelectionDispatcherListener): () => void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngUniqueSelectionDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FngUniqueSelectionDispatcher>;
+}
+
+declare class FngRadioChange {
+    source: FngRadioComponent | null;
+    value: any;
+    constructor(source: FngRadioComponent | null, value: any);
+}
+declare class FngRadioGroupDirective implements AfterContentInit, ControlValueAccessor {
+    private changeDetector;
+    hostClass: boolean;
+    role: string;
+    readonly change: EventEmitter<FngRadioChange>;
+    radios: QueryList<FngRadioComponent> | undefined;
+    get name(): string;
+    set name(value: string);
+    get large(): boolean;
+    set large(v: boolean);
+    get labelPosition(): "before" | "after" | "below";
+    set labelPosition(v: "before" | "after" | "below");
+    get value(): any;
+    set value(newValue: any);
+    get selected(): any | null;
+    set selected(selected: any | null);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    private isLarge;
+    private isDisabled;
+    private isRequired;
+    private innerValue;
+    private isInitialized;
+    private isSelected;
+    private innerName;
+    private innerLabelPosition;
+    constructor(changeDetector: ChangeDetectorRef);
+    controlValueAccessorChangeFn: ((value: any) => void) | undefined;
+    onTouched: (() => void) | undefined;
+    ngAfterContentInit(): void;
+    checkSelectedRadioButton(): void;
+    touch(): void;
+    emitChangeEvent(): void;
+    markRadiosForCheck(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private updateRadioButtonSize;
+    private updateRadioButtonNames;
+    private updateSelectedRadioFromValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngRadioGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngRadioGroupDirective, "[fngRadioGroup]", never, { "name": { "alias": "name"; "required": false; }; "large": { "alias": "large"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, ["radios"], never, true, never>;
+}
+declare class FngRadioComponent implements OnInit, OnDestroy {
+    private changeDetector;
+    private radioDispatcher;
+    name: string | undefined;
+    private innerId;
+    get id(): string;
+    set id(value: string);
+    get inputId(): string;
+    get checked(): boolean;
+    set checked(value: boolean);
+    get value(): any;
+    set value(value: any);
+    get large(): boolean;
+    set large(value: boolean);
+    get labelPosition(): "before" | "after" | "below";
+    set labelPosition(value: "before" | "after" | "below");
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    readonly change: EventEmitter<FngRadioChange>;
+    radioGroup: FngRadioGroupDirective;
+    private isLarge;
+    private isChecked;
+    private isDisabled;
+    private isRequired;
+    private innerValue;
+    private innerLabelPosition;
+    private removeUniqueSelectionListener;
+    constructor(radioGroup: FngRadioGroupDirective, changeDetector: ChangeDetectorRef, radioDispatcher: FngUniqueSelectionDispatcher);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onInputClick(event: Event): void;
+    onInputChange(event: Event): void;
+    markForCheck(): void;
+    private emitChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngRadioComponent, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngRadioComponent, "fng-radio", never, { "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; "large": { "alias": "large"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare class FngSegmentControlComponent implements OnInit, OnChanges, AfterViewInit {
+    id: string | undefined;
+    view: ViewRef | undefined;
+    viewMode: 'text' | 'icon' | 'icon-text';
+    name: string | undefined;
+    value: any;
+    label: string | undefined;
+    icon: string | undefined;
+    iconOnly: boolean | undefined;
+    checked: boolean | undefined;
+    disabled: boolean | undefined;
+    change: EventEmitter<any>;
+    tpl: TemplateRef<any> | undefined;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    onInputChange(event: Event): void;
+    onInputClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSegmentControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSegmentControlComponent, "fng-segment-control", never, { "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+
+interface FngSegmentComponentConfiguration {
+    outline: boolean;
+    iconOnly: boolean;
+}
+declare class FngSegmentComponent implements OnChanges, AfterContentInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    private cd;
+    protected changed: ((value: string) => void)[];
+    protected touched: (() => void)[];
+    protected innerValue: any;
+    writeValue(value: string): void;
+    updateCheckState(): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    private complete;
+    defaultConfig: FngSegmentComponentConfiguration;
+    useIcon: boolean;
+    useIconAndText: boolean;
+    id: string;
+    legend: string;
+    config: FngSegmentComponentConfiguration;
+    controls: QueryList<FngSegmentControlComponent> | undefined;
+    vc: ViewContainerRef | undefined;
+    fngChange: EventEmitter<any>;
+    change: EventEmitter<any>;
+    set value(value: any);
+    get value(): any;
+    constructor(cd: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private html;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSegmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSegmentComponent, "fng-segment", never, { "legend": { "alias": "legend"; "required": false; }; "config": { "alias": "config"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "fngChange": "fngChange"; "change": "change"; }, ["controls"], never, true, never>;
+}
+
+declare class FngSelectOptionComponent implements AfterViewInit {
+    value: any;
+    elementRef: ElementRef;
+    el: HTMLElement | undefined;
+    ngAfterViewInit(): void;
+    update(): Promise<HTMLElement | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSelectOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSelectOptionComponent, "fng-select-option", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface FngSelectOption {
+    value: any;
+    text: string;
+}
+declare class FngSelectComponent implements ControlValueAccessor, OnInit, AfterViewInit, AfterContentInit {
+    cd: ChangeDetectorRef;
+    protected document: Document;
+    protected renderer: Renderer2;
+    protected destroy: DestroyRef;
+    static nextId: number;
+    protected _disabled: boolean;
+    protected _required: boolean;
+    protected _value: any;
+    protected body: HTMLElement;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    get value(): any;
+    set value(value: any);
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    id: string;
+    multiple: boolean;
+    size: number;
+    options: any[];
+    optionsValueKey: string | undefined;
+    optionsTextKey: string | undefined;
+    optionObjectAsValue: boolean | undefined;
+    error: string | undefined;
+    label: string;
+    hideLabel: boolean;
+    hint: string;
+    resetOption: string | undefined;
+    fngSelectOptions: QueryList<FngSelectOptionComponent> | undefined;
+    elementRef: ElementRef | undefined;
+    fngChange: EventEmitter<any>;
+    selectPanelClasses: string[];
+    showOptions: boolean;
+    empty: boolean;
+    triggerWidth: any;
+    checked: Map<any, any>;
+    hasProjectedOptions: boolean;
+    projectedHtml: any[];
+    constructor(cd: ChangeDetectorRef, document: Document, renderer: Renderer2, destroy: DestroyRef);
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(shouldDisable: boolean): void;
+    writeValue(value: any | null): void;
+    getOptionText(index: number): any;
+    getOptionValue(index: number): any;
+    removeChip(event: any, chip: string): void;
+    onOpenedChange(isOpen: boolean): void;
+    close(): void;
+    toggle(): void;
+    select(value: any, event: Event): void;
+    markAsTouched(): void;
+    initProjectedOptions(): void;
+    isEmpty(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSelectComponent, "fng-select", never, { "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "size": { "alias": "size"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionsValueKey": { "alias": "optionsValueKey"; "required": false; }; "optionsTextKey": { "alias": "optionsTextKey"; "required": false; }; "optionObjectAsValue": { "alias": "optionObjectAsValue"; "required": false; }; "error": { "alias": "error"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "resetOption": { "alias": "resetOption"; "required": false; }; }, { "fngChange": "fngChange"; }, ["fngSelectOptions"], ["*"], true, never>;
+}
+
+declare class FngSliderComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    private elementRef;
+    label: string | undefined;
+    min: number;
+    max: number;
+    step: number;
+    digitsInfo: string | undefined;
+    locale: string | undefined;
+    hideValue: boolean;
+    left: number;
+    numberoffset: number;
+    protected innerDisabled: boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected innerValue: number;
+    get value(): number;
+    set value(value: number);
+    private resizeSub;
+    private resizeSubject;
+    constructor(elementRef: ElementRef);
+    onChange: ((value: number) => void) | undefined;
+    onTouched: (() => void) | undefined;
+    onResize(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: any): void;
+    updateValuePosition(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSliderComponent, "fng-slider", never, { "label": { "alias": "label"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "digitsInfo": { "alias": "digitsInfo"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "hideValue": { "alias": "hideValue"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FngSwitchComponent implements ControlValueAccessor {
+    private changeDetector;
+    name: string | undefined;
+    large: boolean;
+    labelPosition: 'before' | 'after' | 'below';
+    private innerId;
+    get id(): string;
+    set id(value: string);
+    get inputId(): string;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private isChecked;
+    get disabled(): any;
+    set disabled(value: any);
+    private isDisabled;
+    value: string | undefined;
+    get required(): boolean;
+    set required(value: boolean);
+    private isRequired;
+    readonly change: EventEmitter<boolean>;
+    constructor(changeDetector: ChangeDetectorRef);
+    controlValueAccessorChangeFn: ((value: any) => void) | undefined;
+    onTouched: (() => any) | undefined;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInteractionEvent(event: Event): void;
+    onInputClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngSwitchComponent, "fng-switch", never, { "name": { "alias": "name"; "required": false; }; "large": { "alias": "large"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "id": { "alias": "id"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
+}
+
+/**
+ * A custom form element for text inputs.
+ */
+declare class FngTextAreaComponent implements OnInit, ControlValueAccessor {
+    /**
+     * The text input label.
+     */
+    label: string | undefined;
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private innerReadonly;
+    placeholder: string | undefined;
+    tabindex: number;
+    name: string | undefined;
+    /**
+     * When true the control's disabled attribute is set
+     * and it gets addeed the .disabled css class.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected innerDisabled: boolean;
+    /**
+     * The inner value.
+     */
+    innerValue: string | undefined;
+    /**
+     * The getter for value.
+     */
+    get value(): string | undefined;
+    /**
+     * The setter for value.
+     */
+    set value(value: string | undefined);
+    get required(): boolean;
+    set required(value: boolean);
+    protected innerRequired: boolean;
+    /**
+     * Error description when invalid.
+     */
+    error: string | undefined;
+    /**
+     * Hint description when valid.
+     */
+    hint: string | undefined;
+    /**
+     * the height is managed by classes. the last one is "fwe-row-10"
+     */
+    get rows(): number;
+    set rows(value: number);
+    protected innerRows: number;
+    maxlength: number;
+    inputElement: ElementRef | undefined;
+    /**
+     * When true the text input has focus.
+     */
+    focused: boolean;
+    /**
+     * Triggered on change.
+     */
+    onChange: ((value: string | undefined) => void) | undefined;
+    /**
+     * Triggered on touch.
+     */
+    onTouched: (() => void) | undefined;
+    /**
+     * Called on component initialisation.
+     */
+    ngOnInit(): void;
+    /**
+     * Writes the value.
+     * @param value The value.
+     */
+    writeValue(value: string): void;
+    /**
+     * Registers a function to onChange.
+     * @param fn The registered function.
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Registers a function to onTouched.
+     * @param fn The registered function.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Called when the text input is in focus.
+     */
+    onFocus(): void;
+    onInput(event: any): void;
+    /**
+     * Called when the text input blurs.
+     */
+    onBlur(): void;
+    /**
+     * Sets the disabled state.
+     * @param isDisabled When true the control is disabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTextAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTextAreaComponent, "fng-text-area", never, { "label": { "alias": "label"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "error": { "alias": "error"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FngValueAccessorBaseDirective<T> implements ControlValueAccessor {
+    disabled: boolean;
+    protected innerValue: T | undefined;
+    protected changed: ((value: T) => void)[];
+    protected touched: (() => void)[];
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    touch(): void;
+    writeValue(value: T): void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngValueAccessorBaseDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FngValueAccessorBaseDirective<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface FngTextEditorConfiguration {
+    toolbar?: {
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        alignCenter?: boolean;
+        alignRight?: boolean;
+        bulletList?: boolean;
+        orderedList?: boolean;
+        image?: boolean;
+        link?: boolean;
+    };
+    sanitizing?: {
+        skipDefaultSanitizing?: boolean;
+        skipWhitespaceHandling?: boolean;
+        sanitizingFn?: (ds: DomSanitizer, value: string) => string;
+    };
+    focusCursorToEndOnWrite?: boolean;
+}
+declare class FngTextEditorComponent extends FngValueAccessorBaseDirective<string | null | undefined> implements OnInit, AfterViewInit, OnChanges {
+    elementRef: ElementRef;
+    private renderer;
+    private domSanitizer;
+    id: string | undefined;
+    quillEditor: QuillType;
+    editorElem: HTMLElement;
+    defaultConfig: FngTextEditorConfiguration;
+    btnBold: ElementRef | undefined;
+    btnItalic: ElementRef | undefined;
+    btnUnderline: ElementRef | undefined;
+    btnAlignCenter: ElementRef | undefined;
+    btnAlignRight: ElementRef | undefined;
+    btnLink: ElementRef | undefined;
+    btnUl: ElementRef | undefined;
+    btnOl: ElementRef | undefined;
+    btnImage: ElementRef | undefined;
+    fngChange: EventEmitter<any>;
+    change: EventEmitter<any>;
+    config: FngTextEditorConfiguration | null | undefined;
+    modules: any;
+    label: string | undefined;
+    readOnly: boolean;
+    maxLength: number;
+    error: string | undefined;
+    hint: string | undefined;
+    set value(value: string | null | undefined);
+    get value(): string | null | undefined;
+    valueGetter: (editorElement: HTMLElement) => string | any;
+    valueSetter: (quillEditor: QuillType, value: any) => any;
+    constructor(elementRef: ElementRef, renderer: Renderer2, domSanitizer: DomSanitizer);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: string): void;
+    setDisabledState(isDisabled?: boolean): void;
+    setReadOnlyState(): void;
+    delegate(event: any, action: string): void;
+    currentLength(): number;
+    hideDivider(name: string): boolean;
+    private setEditorLabel;
+    private handle;
+    private addWhitespaceMatcher;
+    private addImageMatcher;
+    private handleWhitespace;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngTextEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FngTextEditorComponent, "fng-text-editor", never, { "config": { "alias": "config"; "required": false; }; "modules": { "alias": "modules"; "required": false; }; "label": { "alias": "label"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "error": { "alias": "error"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "fngChange": "fngChange"; "change": "change"; }, never, never, true, never>;
+}
+
+declare class FestoAngularFormsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FestoAngularFormsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FestoAngularFormsModule, never, [typeof i1.ReactiveFormsModule, typeof i1.FormsModule, typeof FngCheckboxComponent, typeof FngColorIndicatorComponent, typeof FngColorPickerComponent, typeof FngTextInputComponent, typeof FngTimePickerDropdownComponent, typeof FngTimePickerComponent, typeof FngDatePickerComponent, typeof FngDateRangePickerComponent, typeof FngRadioGroupDirective, typeof FngRadioComponent, typeof FngSegmentComponent, typeof FngSegmentControlComponent, typeof FngSelectOptionComponent, typeof FngSelectComponent, typeof FngSliderComponent, typeof FngSwitchComponent, typeof FngTextAreaComponent, typeof FngTextEditorComponent], [typeof i1.ReactiveFormsModule, typeof i1.FormsModule, typeof FngCheckboxComponent, typeof FngColorIndicatorComponent, typeof FngColorPickerComponent, typeof FngTextInputComponent, typeof FngTimePickerDropdownComponent, typeof FngTimePickerComponent, typeof FngDatePickerComponent, typeof FngDateRangePickerComponent, typeof FngRadioGroupDirective, typeof FngRadioComponent, typeof FngSegmentComponent, typeof FngSegmentControlComponent, typeof FngSelectOptionComponent, typeof FngSelectComponent, typeof FngSliderComponent, typeof FngSwitchComponent, typeof FngTextAreaComponent, typeof FngTextEditorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FestoAngularFormsModule>;
+}
+
+declare class FngSafeHtmlPipe implements PipeTransform {
+    protected sanitizer: DomSanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: any): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FngSafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FngSafeHtmlPipe, "fngSafeHtml", true>;
+}
+
+declare class FestoAngularModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FestoAngularModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FestoAngularModule, never, [typeof FngSafeHtmlPipe, typeof FestoAngularComponentsModule, typeof FestoAngularFormsModule, typeof FestoAngularModalsModule, typeof FestoAngularSnackbarModule], [typeof FngSafeHtmlPipe, typeof FestoAngularComponentsModule, typeof FestoAngularFormsModule, typeof FestoAngularModalsModule, typeof FestoAngularSnackbarModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FestoAngularModule>;
+}
+
+export { ALL_POSITIONS, ChipType, FestoAngularComponentsModule, FestoAngularFormsModule, FestoAngularModalsModule, FestoAngularModule, FestoAngularSnackbarModule, FngAccordionActions, FngAccordionComponent, FngAccordionHeaderActions, FngAccordionHeaderComponent, FngAccordionItemBodyComponent, FngAccordionItemComponent, FngAccordionItemHeaderComponent, FngAlertComponent, FngBottomSheetComponent, FngBreadcrumbComponent, FngButtonComponent, FngCheckboxComponent, FngChipComponent, FngChipContainerComponent, FngClickOutsideDirective, FngColorIndicatorComponent, FngColorPickerComponent, FngConfirmComponent, FngCustomModalComponent, FngDatePickerComponent, FngDateRangePickerComponent, FngImageGalleryComponent, FngLegendComponent, FngLegendDirective, FngLinkButtonComponent, FngLoadingIndicatorComponent, FngMobileFlyoutComponent, FngMobileFlyoutItemComponent, FngMobileFlyoutPageComponent, FngModalService, FngOverlayContentComponent, FngOverlayOutletDirective, FngPaginationComponent, FngPaginationType, FngPopoverComponent, FngPopoverContentComponent, FngPopoverContentDirective, FngPopoverContentTypes, FngPopoverMenuComponent, FngPopoverService, FngProgressComponent, FngPromptComponent, FngRadioChange, FngRadioComponent, FngRadioGroupDirective, FngSafeHtmlPipe, FngScrollableDirective, FngSearchInputComponent, FngSearchSuggestion, FngSegmentComponent, FngSegmentControlComponent, FngSelectComponent, FngSelectOptionComponent, FngSidebarOverlayComponent, FngSliderComponent, FngSnackbarComponent, FngSnackbarContainerComponent, FngSnackbarContainerDirective, FngSnackbarService, FngStepHorizontalComponent, FngStepVerticalComponent, FngStepperHorizontalComponent, FngStepperVerticalComponent, FngSwitchComponent, FngTabPaneComponent, FngTableHeaderCellDirective, FngTabsComponent, FngTextAreaComponent, FngTextEditorComponent, FngTextInputComponent, FngTimePickerComponent, FngTimePickerDropdownComponent, FngTooltipDirective, POSITION_MAP, PREDEFINED_COLORS };
+export type { ConnectedPositionName, FngAlertData, FngBeforeTabChangeEvent, FngConfirmData, FngDatePickerOptions, FngDateRangePickerOptions, FngImageDescriptiveContent, FngImageGalleryData, FngLegendItem, FngPopoverCloseEvent, FngPopoverContent, FngPopoverContentActions, FngPopoverContentOptions, FngPopoverLegendOptions, FngPopoverMenu, FngPopoverMenuAction, FngPopoverMenuActionAware, FngPopoverMenuOptions, FngPopoverOptions, FngPopoverParams, FngPopoverPosition, FngPopoverTypes, FngPromptData, FngScrollStrategy, FngScrollableAware, FngSegmentComponentConfiguration, FngSelectOption, FngSnackDescription, FngSnackbarConfig, FngSnackbarData, FngTab, FngTabDimensions, FngTabItemAppearance, FngTabScrollAnimation, FngTabScrollHorizontalEdges, FngTabViewType, FngTableColumnOrder, FngTabsConfiguration, FngTextEditorConfiguration, FngTimePickerOptions, FngTooltipOptions, Modal, ModalOptions, ModalResult, ModalUserAction };