import * as i1 from '@fundamental-ngx/platform/shared';
import { MatchingStrategy, DataProvider, PlatformConfig, OptionItem, CollectionBaseInput, ComboBoxDataSource, BaseInput, SelectItem, ColumnLayout, HintInput, InlineLayout, FieldHintInput, PlatformFormField, FieldHintOptions, FormFieldGroup, FormGroupContainer, HintOptions, InLineLayoutCollectionBaseInput, PlatformFormFieldControl, Column, ResponsiveBreakPointConfig, ResponsiveBreakpointsService, FormError, FormFieldErrorDirectiveContext, HintContent, FormFieldErrorContext, FormErrorHeading, FormErrorDescription, SelectableOptionItem, MultiComboBoxDataSource, MultiInputOption, MultiInputDataSource } from '@fundamental-ngx/platform/shared';
import * as i0 from '@angular/core';
import { InjectionToken, OnInit, TemplateRef, EventEmitter, ElementRef, AfterViewInit, OnDestroy, ViewContainerRef, Injector, Type, QueryList, OnChanges, ChangeDetectorRef, SimpleChanges, PipeTransform, ModuleWithProviders, Provider, StaticProvider, AfterContentInit, DestroyRef, Signal, Renderer2, WritableSignal, AfterContentChecked, AfterViewChecked } from '@angular/core';
import { FormGroup, ValidatorFn, AsyncValidatorFn, AbstractControlOptions, FormControl, FormBuilder, NgControl, FormControlStatus, NgForm, FormGroupDirective, AbstractControl } from '@angular/forms';
import * as i1$1 from '@fundamental-ngx/cdk/forms';
import { SingleDropdownValueControl, FormStates, FormField, FormFieldControl, CvaControl } from '@fundamental-ngx/cdk/forms';
import { Subject, Observable, BehaviorSubject, Subscription } from 'rxjs';
import { Nullable, ContentDensity, FocusEscapeDirection, DynamicComponentService, FdkAsyncProperty, ColorAccent, TemplateDirective, RangeSelector, ContentDensityService } from '@fundamental-ngx/cdk/utils';
import { FdDate } from '@fundamental-ngx/core/datetime';
import { ObjectStatus } from '@fundamental-ngx/core/object-status';
import { DialogConfig } from '@fundamental-ngx/core/dialog';
import { ListComponent } from '@fundamental-ngx/core/list';
import { MobileMode, MobileModeBase, MobileModeConfig } from '@fundamental-ngx/core/mobile-mode';
import { PopoverFillMode, Placement, SpecialDayRule } from '@fundamental-ngx/core/shared';
import { FdCheckboxValues, CheckboxComponent as CheckboxComponent$1 } from '@fundamental-ngx/core/checkbox';
import { SelectionModel } from '@angular/cdk/collections';
import { DateRange, CalendarType, DaysOfWeek, FdCalendarView, CalendarYearGrid } from '@fundamental-ngx/core/calendar';
import { DatePickerComponent } from '@fundamental-ngx/core/date-picker';
import { DatetimePickerComponent } from '@fundamental-ngx/core/datetime-picker';
import * as i16 from '@fundamental-ngx/core/content-density';
import { ContentDensityMode, ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { FormInputMessageGroupComponent } from '@fundamental-ngx/core/form';
import { TriggerConfig } from '@fundamental-ngx/core/popover';
import { KeyValue } from '@angular/common';
import { ButtonModel } from '@fundamental-ngx/platform/button';
import { BaseButton } from '@fundamental-ngx/core/button';
import { TokenizerComponent } from '@fundamental-ngx/core/token';
import { ListComponent as ListComponent$1, SelectionType, ModifyItemEvent } from '@fundamental-ngx/platform/list';
import { FocusableOption } from '@angular/cdk/a11y';
import { IconFont } from '@fundamental-ngx/core/icon';
import { SelectComponent as SelectComponent$1 } from '@fundamental-ngx/core/select';
import { TimePickerComponent } from '@fundamental-ngx/core/time-picker';

declare const COMBOBOX_COMPONENT: InjectionToken<string[]>;
/**
 * Combobox Interface to have typing and avoid circular dependency between
 * ComboboxComponent <==> ComboboxMobileComponent
 */
interface ComboboxInterface extends MobileMode {
    inputText: string;
    openChange: Subject<boolean>;
    dialogApprove(): void;
    dialogDismiss(backup: string): void;
    detectChanges(): void;
}

declare class ComboboxMobileComponent extends MobileModeBase<ComboboxInterface> implements OnInit {
    /** @hidden */
    dialogTemplate: TemplateRef<any>;
    /** @hidden
     * For internal usage
     * Control element, which will be rendered inside dialog.
     * List element, which will be rendered inside dialog.
     */
    childContent: Nullable<{
        listTemplate: TemplateRef<any>;
        controlTemplate: TemplateRef<any>;
    }>;
    /** @hidden */
    private _selectedBackup;
    /** @hidden */
    constructor(comboboxComponent: ComboboxInterface);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    handleDismiss(): void;
    /** @hidden */
    handleApprove(): void;
    /** @hidden */
    private _toggleDialog;
    /** @hidden */
    private _listenOnMultiInputOpenChange;
    /** @hidden */
    private _open;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxMobileComponent, "fdp-combobox-mobile", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformComboboxMobileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformComboboxMobileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformComboboxMobileModule, never, [typeof ComboboxMobileComponent], [typeof ComboboxMobileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformComboboxMobileModule>;
}

/**
 * Default options for Combobox
 */
declare class ComboboxConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /**
     * String matching strategy for typeahead list. Default: 'starts with per term'
     */
    matchingStrategy: MatchingStrategy;
    /**
     * Maps data providers
     */
    providers: Map<string, DataProvider<any>> | null;
    /** @hidden */
    constructor(platformConfig: PlatformConfig);
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<ComboboxConfig>): (platformConfig: PlatformConfig) => ComboboxConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ComboboxConfig>;
}

interface AutoCompleteEvent {
    term: string;
    forceClose: boolean;
}
declare class AutoCompleteDirective {
    private readonly _elementRef;
    /** Values that will fill missing text in the input. */
    options: OptionItem[];
    /**
     * Input text, that is taken from ngModel of formControl,
     * there has to be difference between native input value and model value
     */
    inputText: string;
    /** Check is directive use in mobile view to prevent additional blur events */
    mobile: boolean;
    /** Event thrown, when the auto ahead text is accepted */
    readonly onComplete: EventEmitter<AutoCompleteEvent>;
    /** @hidden */
    private readonly _completeKeys;
    /** @hidden */
    private readonly _fillKeys;
    /** @hidden */
    private readonly _stopKeys;
    /** @hidden */
    private _oldValue;
    /** @hidden */
    private _lastKeyUpEvent;
    /** @hidden */
    private get _element();
    /** @hidden */
    private _isComposing;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_elementRef: ElementRef<HTMLInputElement>);
    /** @hidden */
    handleBlur(): void;
    /** @hidden */
    handleKeyboardEvent(event: KeyboardEvent): void;
    /** @hidden */
    private _typeahead;
    /** @hidden */
    private _setSelectionRange;
    /** @hidden */
    private _isControlKey;
    /** @hidden */
    private _triggerTypeAhead;
    /** @hidden */
    private _sendCompleteEvent;
    /** @hidden */
    private _searchByStrategy;
    /** @hidden */
    private _findByStrategyStartsWith;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoCompleteDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoCompleteDirective, "[fdp-auto-complete]", never, { "options": { "alias": "options"; "required": false; }; "inputText": { "alias": "inputText"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; }, { "onComplete": "onComplete"; }, never, never, true, never>;
}

type TextAlignment = 'left' | 'right';
type FdpComboBoxDataSource<T> = ComboBoxDataSource<T> | Observable<T[]> | T[];
declare abstract class BaseCombobox extends CollectionBaseInput implements SingleDropdownValueControl, AfterViewInit, OnDestroy {
    readonly dialogConfig: DialogConfig;
    protected comboboxConfig: ComboboxConfig;
    /** @hidden Method to emit change event */
    abstract emitChangeEvent<K>(value: K): void;
    /** @hidden Define is this item selected */
    abstract isSelectedOptionItem(selectedItem: OptionItem): boolean;
    /** @hidden Emit select OptionItem */
    abstract selectOptionItem(item: OptionItem): void;
    /** @hidden Define value as selected */
    abstract setAsSelected(item: OptionItem[]): void;
    /** Provides maximum height for the optionPanel */
    maxHeight: string;
    /** Whether the autocomplete should be enabled; Enabled by default */
    autoComplete: boolean;
    /**
     * Todo: Name of the entity for which DataProvider will be loaded. You can either pass list of
     * items or use this entityClass and internally we should be able to do lookup to some registry
     * and retrieve the best matching DataProvider that is set on application level
     */
    entityClass: string;
    /** Whether the combobox should be built on mobile mode */
    mobile: boolean;
    /** Multi Input Mobile Configuration, it's applied only, when mobile is enabled */
    mobileConfig: MobileModeConfig;
    /** Tells the combo if we need to group items */
    group: boolean;
    /** A field name to use to group data by (support dotted notation) */
    groupKey?: string;
    /** The field to show data in secondary column */
    secondaryKey?: string;
    /** Show the second column (Applicable for two columns layout) */
    showSecondaryText: boolean;
    /** Horizontally align text inside the second column (Applicable for two columns layout) */
    secondaryTextAlignment: TextAlignment;
    /** Turns on/off Adjustable Width feature */
    autoResize: boolean;
    /**
     * Preset options for the Select body width, whatever is chosen, the body has a 600px limit.
     * `at-least` will apply a minimum width to the body equivalent to the width of the control. - Default
     * `equal` will apply a width to the body equivalent to the width of the control.
     * 'fit-content' will apply width needed to properly display items inside, independent of control.
     */
    fillControlMode: PopoverFillMode;
    /**
     * Whether AddOn Button should be focusable
     * @default true
     */
    buttonFocusable: boolean;
    /**
     * The trigger events that will open/close the options popover.
     * Accepts any [HTML DOM Events](https://www.w3schools.com/jsref/dom_obj_event.asp).
     */
    triggers: string[];
    /** Whether the combobox should close, when a click is performed outside its boundaries. True by default */
    closeOnOutsideClick: boolean;
    /** Whether list item options should be rendered as byline. */
    byline: boolean;
    /** Datasource for suggestion list */
    set dataSource(value: FdpComboBoxDataSource<any>);
    get dataSource(): FdpComboBoxDataSource<any>;
    /** Value of the combobox */
    set value(value: any);
    get value(): any;
    /**
     * Action to perform when user shifts focus from the dropdown.
     * - `close` will close the dropdown preserving previously selected value.
     * - `closeAndSelect` will close the dropdown and select last focused dropdown item.
     */
    tabOutStrategy: 'close' | 'closeAndSelect';
    /** Event emitted when data loading is started. */
    onDataRequested: EventEmitter<void>;
    /** Event emitted when data loading is finished. */
    onDataReceived: EventEmitter<void>;
    /** @hidden */
    listComponent: ListComponent;
    /** @hidden */
    private readonly _customTemplates;
    /** @hidden */
    private readonly _customItemDef;
    /** @hidden Custom Option item Template */
    optionItemTemplate: TemplateRef<any>;
    /** @hidden Custom Group Header item Template */
    groupItemTemplate: TemplateRef<any>;
    /** @hidden Custom Secondary item Template */
    secondaryItemTemplate: TemplateRef<any>;
    /** @hidden Custom Selected option item Template */
    selectedItemTemplate: TemplateRef<any>;
    /** @hidden */
    searchInputElement: ElementRef<HTMLInputElement>;
    /** Input text of the input. */
    set inputText(value: string);
    get inputText(): string;
    /** Whether the combobox is opened. */
    isOpen: boolean;
    /** Whether a combobox can be closed */
    get canClose(): boolean;
    /** @hidden List of matched suggestions */
    _suggestions: OptionItem[];
    /** @hidden Max width of list container */
    maxWidth: number | null;
    /** @hidden Min width of list container */
    minWidth: number | null;
    /** @hidden Need for opening mobile version */
    openChange: Subject<boolean>;
    /** @hidden */
    get isGroup(): boolean;
    /** Is suggestions list empty */
    get isSuggestionsListEmpty(): boolean;
    /** @hidden */
    _flatSuggestions: OptionItem[];
    /** @hidden */
    protected _dataSource: FdpComboBoxDataSource<any>;
    /** @hidden */
    private _inputTextValue;
    /** @hidden */
    private readonly _matchingStrategy;
    /** @hidden */
    private _dsSubscription?;
    /** @hidden */
    private _element;
    /** @hidden */
    private readonly _focusTrapService;
    /** Keys, that won't trigger the popover's open state, when dispatched on search input */
    private readonly _nonOpeningKeys;
    /** Keys, that are numbers from number keypad */
    private readonly _numberPadNumberKeys;
    /** @hidden */
    protected constructor(dialogConfig: DialogConfig, comboboxConfig: ComboboxConfig);
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Is empty search field */
    get isEmptyValue(): boolean;
    /** write value for ControlValueAccessor */
    writeValue(value: any): void;
    /** @hidden */
    searchTermChanged(text: string): void;
    /** @hidden */
    isOpenChangeHandle(isOpen: boolean): void;
    /** @hidden */
    _onOpenChange(isOpen: boolean): void;
    /** @hidden */
    handleOptionItem(value: OptionItem): void;
    /** @hidden */
    handlePressEnter(event: KeyboardEvent, value: OptionItem): void;
    /**
     * Handle Click on Button
     * @hidden
     */
    onPrimaryButtonClick(): void;
    /**
     * Handle click on input group in mobile mode
     * @hidden
     */
    openInMobileMode(): void;
    /**
     * Handle Keydown on Input
     * @hidden
     */
    onInputKeydownHandler(event: KeyboardEvent): void;
    /** Method passed to list component */
    handleListFocusEscape(direction: FocusEscapeDirection): void;
    /** @hidden */
    _onCompleteTerm(event: AutoCompleteEvent): void;
    /** @hidden */
    toggleSelectionByInputText(text?: string): void;
    /** @hidden */
    _close(): void;
    /** @hidden */
    protected _getSelectItemByInputValue(displayValue: string): OptionItem | undefined;
    /** @hidden */
    protected get ds(): ComboBoxDataSource<any>;
    /** @hidden Map grouped values to array. */
    protected _flatGroups(items: OptionItem[]): OptionItem[];
    /** @hidden */
    private _displayFn;
    /** @hidden */
    private _secondaryFn;
    /**
     * @hidden
     * Method that picks other value moved from current one by offset, called only when combobox is closed
     */
    private _chooseOtherItem;
    /** @hidden */
    private _getSelectItemByValue;
    /** @hidden */
    private _initializeDataSource;
    /** @hidden */
    private _openDataStream;
    /** @hidden */
    private _toDataStream;
    /** @hidden */
    private _initWindowResize;
    /** @hidden */
    private _getOptionsListWidth;
    /**
     * Convert original data to OptionItems Interface
     * @hidden
     */
    private _convertToOptionItems;
    /**
     * Convert data to OptionItems Interface
     * @hidden
     */
    private _convertObjectsToOptionItems;
    /**
     * Convert object[] data to Group OptionItems Interface
     * @hidden
     */
    private _convertObjectsToGroupOptionItems;
    /**
     * Convert object[] data to Secondary OptionItems Interface
     * @hidden
     */
    private _convertObjectsToSecondaryOptionItems;
    /**
     * Convert Primitive data(Boolean, String, Number) to OptionItems Interface
     * @hidden
     */
    private _convertPrimitiveToOptionItems;
    /**
     * Convert object[] to OptionItems Interface (Default)
     * @hidden
     */
    private _convertObjectsToDefaultOptionItems;
    /** @hidden Assign custom templates */
    private _assignCustomTemplates;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseCombobox, [{ optional: true; }, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseCombobox, never, never, { "maxHeight": { "alias": "maxHeight"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; "entityClass": { "alias": "entityClass"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "group": { "alias": "group"; "required": false; }; "groupKey": { "alias": "groupKey"; "required": false; }; "secondaryKey": { "alias": "secondaryKey"; "required": false; }; "showSecondaryText": { "alias": "showSecondaryText"; "required": false; }; "secondaryTextAlignment": { "alias": "secondaryTextAlignment"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "byline": { "alias": "byline"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tabOutStrategy": { "alias": "tabOutStrategy"; "required": false; }; }, { "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; }, ["_customTemplates", "_customItemDef"], never, true, never>;
}

declare class ComboboxSelectionChangeEvent {
    source: ComboboxComponent;
    payload: any;
    /**
     * Combobox selection event
     * @param source Combobox component
     * @param payload Selected option
     */
    constructor(source: ComboboxComponent, payload: any);
}
declare class ComboboxComponent extends BaseCombobox implements ComboboxInterface, OnInit, AfterViewInit {
    readonly _dynamicComponentService: DynamicComponentService;
    private readonly _viewContainerRef;
    private readonly _injector;
    private providers;
    /** Event emitted when item is selected. */
    selectionChange: EventEmitter<ComboboxSelectionChangeEvent>;
    /** @hidden */
    searchInputElement: ElementRef<HTMLInputElement>;
    /** @hidden */
    controlTemplate: TemplateRef<any>;
    /** @hidden */
    listTemplate: TemplateRef<any>;
    /** @hidden */
    _selectedElement?: OptionItem;
    /** @hidden */
    _itemMousedown: boolean;
    /** @hidden */
    constructor(_dialogConfig: DialogConfig, _dynamicComponentService: DynamicComponentService, _viewContainerRef: ViewContainerRef, _injector: Injector, providers: Map<string, DataProvider<any>>, _comboboxConfig: ComboboxConfig);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    _onBlur(event: FocusEvent): void;
    /** @hidden Method to emit change event */
    emitChangeEvent<T>(modelValue: T): void;
    /** @hidden Method to set selected item */
    selectOptionItem(item: OptionItem, shouldClosePopover?: boolean): void;
    /** @hidden Method to set as selected */
    setAsSelected(item: OptionItem[]): void;
    /** @hidden Define is selected item selected */
    isSelectedOptionItem(selectedItem: any): boolean;
    /** @hidden Define is selected item selected by display value */
    isSelectedOptionItemByDisplayValue(selectedItem: any): boolean;
    /** Handle dialog dismissing, closes popover and sets backup data. */
    dialogDismiss(term: string): void;
    /** Handle dialog approval, closes popover and propagates data changes. */
    dialogApprove(): void;
    /** @hidden */
    onItemFocused(value: OptionItem): void;
    /** @hidden */
    _getLabelledBy(): Nullable<string>;
    /** @hidden if not selected update model */
    private _checkAndUpdate;
    /** @hidden Update model */
    private _updateModel;
    /** @hidden */
    private _setUpMobileMode;
    /** @hidden */
    private _getSelectedOptionItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxComponent, [{ optional: true; }, null, null, null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComboboxComponent, "fdp-combobox", never, {}, { "selectionChange": "selectionChange"; }, never, ["*", "*"], true, never>;
}

declare const FDP_COMBOBOX_ITEM_DEF: InjectionToken<FdpComboboxItemDef<unknown>>;
type FdoComboboxItemDefType = 'optionItemTemplate' | 'groupItemTemplate' | 'secondaryItemTemplate' | 'selectedItemTemplate';
declare abstract class FdpComboboxItemDef<T = unknown> {
    /** @hidden */
    abstract name: FdoComboboxItemDefType;
    /** @hidden */
    templateRef: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpComboboxItemDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FdpComboboxItemDef<any>, never, never, {}, {}, never, never, true, never>;
}
declare class ComboboxItemDirective<T = unknown> extends FdpComboboxItemDef<{
    $implicit: T;
    index: number;
}> {
    /** @hidden */
    useModel: T;
    /** @hidden */
    name: FdoComboboxItemDefType;
    /** @hidden */
    static ngTemplateContextGuard<T>(dir: ComboboxItemDirective<T>, ctx: {
        $implicit: T;
        index: number;
    }): ctx is {
        $implicit: T;
        index: number;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxItemDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxItemDirective<any>, "[fdpComboboxItem]", never, { "useModel": { "alias": "fdpComboboxItemUse"; "required": false; }; }, {}, never, never, true, never>;
}
declare class ComboboxSelectedItemDirective<T = unknown> extends FdpComboboxItemDef<{
    $implicit: T;
    index: number;
}> {
    /** @hidden */
    useModel: T;
    /** @hidden */
    name: FdoComboboxItemDefType;
    /** @hidden */
    static ngTemplateContextGuard<T>(dir: ComboboxSelectedItemDirective<T>, ctx: {
        $implicit: T;
        index: number;
    }): ctx is {
        $implicit: T;
        index: number;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxSelectedItemDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxSelectedItemDirective<any>, "[fdpComboboxSelectedItem]", never, { "useModel": { "alias": "fdpComboboxSelectedItemUse"; "required": false; }; }, {}, never, never, true, never>;
}
declare class ComboboxItemGroupDirective extends FdpComboboxItemDef<{
    $implicit: {
        label: string;
    };
}> {
    /** @hidden */
    name: FdoComboboxItemDefType;
    /** @hidden */
    static ngTemplateContextGuard(dir: ComboboxItemGroupDirective, ctx: {
        $implicit: {
            label: string;
        };
    }): ctx is {
        $implicit: {
            label: string;
        };
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxItemGroupDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxItemGroupDirective, "[fdpComboboxGroup]", never, {}, {}, never, never, true, never>;
}
declare class ComboboxSecondaryItemDirective<T = unknown> extends FdpComboboxItemDef<{
    $implicit: T;
}> {
    /** @hidden */
    useModel: T;
    /** @hidden */
    name: FdoComboboxItemDefType;
    /** @hidden */
    static ngTemplateContextGuard<T>(dir: ComboboxSelectedItemDirective<T>, ctx: {
        $implicit: T;
    }): ctx is {
        $implicit: T;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxSecondaryItemDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxSecondaryItemDirective<any>, "[fdpComboboxSecondaryItem]", never, { "useModel": { "alias": "fdpComboboxSecondaryItemUse"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformComboboxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformComboboxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformComboboxModule, never, [typeof ComboboxComponent, typeof ComboboxItemDirective, typeof ComboboxSelectedItemDirective, typeof ComboboxItemGroupDirective, typeof ComboboxSecondaryItemDirective], [typeof ComboboxComponent, typeof ComboboxItemDirective, typeof ComboboxSelectedItemDirective, typeof ComboboxItemGroupDirective, typeof ComboboxSecondaryItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformComboboxModule>;
}

/**
 * @license
 * F. Kolar
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *
 */

type InputType = 'text' | 'number' | 'email' | 'password';
/**
 * Input field implementation to be compliant with our FormGroup/FormField design and also to
 * achieve certain this in Angular this component is re-using several ideas from MatDesign
 *
 */
declare class InputComponent extends BaseInput implements OnInit, AfterViewInit {
    /** Input type */
    type: InputType;
    /**
     * @hidden
     * This `required` field is used internally by other components such as Input Group.
     * Input group will not be able to set required value to input, until `required` is input through the`@Input` property.
     */
    required: boolean;
    /** return the value in the text box */
    set value(value: any);
    get value(): any;
    /** Emits event on focus change */
    focusChange: EventEmitter<boolean>;
    /** @hidden */
    get inputElementRef(): ElementRef;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    _onFocus(): void;
    /** @hidden */
    _onBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "fdp-input", never, { "type": { "alias": "type"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "focusChange": "focusChange"; }, never, never, true, never>;
}

interface DynamicFormGroup extends FormGroup {
    controls: {
        [key: string]: DynamicFormGroupControl;
    };
}

type DynamicFormItemChoice<T = any> = DynamicFormItemChoiceTypes<T>[] | Observable<DynamicFormItemChoiceTypes<T>[]> | Promise<DynamicFormItemChoiceTypes<T>[]>;
type DynamicFormItemChoiceTypes<T = any> = number | string | SelectItem<T>;
/** Advanced error type. Used to render more complex error view with custom error type. */
interface DynamicFormItemValidationObject {
    /** Error heading. */
    heading: string;
    /** Error description. */
    description?: string;
    /** Error state */
    type: FormStates;
}
type DynamicFormItemValidationResult = null | boolean | string | DynamicFormItemValidationObject;
/**
 * Dynamic form item type.
 *
 * `T` type represents additional type properties.
 * `U` type represents additional `DynamicFormFieldItem` interface.
 */
type DynamicFormItem<T extends Record<string, any> = Record<string, any>, U extends BaseDynamicFormFieldItem = AnyDynamicFormFieldItem> = DynamicFormFieldGroup | DynamicFormFieldItem<T, U>;
type DynamicFormItemMap<T extends Record<string, any> = Record<string, any>, U extends BaseDynamicFormFieldItem = AnyDynamicFormFieldItem> = DynamicFormFieldGroupMap | DynamicFormFieldItem<T, U>;
interface BaseDynamicFormFieldGroup {
    /**
     * @description
     * ID of the form item, if not provided, name will be used instead
     */
    id?: string;
    /**
     * @description
     * Name of the form item in form.
     */
    name: string;
    /**
     * @description
     * Display name of the form item.
     * @param formValue the form value hash.
     */
    message?: string;
    /**
     * @description
     * Rank is used for ordering.
     * Than lower number then higher priority.
     */
    rank?: number;
    /**
     * @description
     * Additional set of options that can affect UI of the form field group.
     */
    guiOptions?: BaseDynamicFormItemGuiOptions;
}
interface DynamicFormFieldGroup extends BaseDynamicFormFieldGroup {
    /**
     * @description
     * List of @see DynamicFormItem representing the list of items
     * to be rendered in the form.
     */
    items?: DynamicFormFieldItem[];
}
interface DynamicFormFieldGroupMap extends BaseDynamicFormFieldGroup {
    /**
     * @description
     * Map of @see DynamicFormItem representing the list of items
     * to be rendered in the form.
     */
    items?: Map<string, DynamicFormItemMap>;
}
type FdpFormGeneratorAsyncProperty<T = string> = FdkAsyncProperty<T>;
interface BaseDynamicFormFieldItem<T = any> {
    /**
     * @description
     * Type of the form item. E.g. input, textarea, checkbox, etc.
     */
    type: string;
    /**
     * @description
     * ID of the form item, if not provided, name will be used instead
     */
    id?: string;
    /**
     * @description
     * Name of the form item in form.
     */
    name: string;
    /**
     * @description
     * Display name of the form item.
     * @param formValue the form value hash.
     */
    message: FdkAsyncProperty<string> | ((formValue?: DynamicFormValue) => FdkAsyncProperty<string>);
    /**
     * @description
     * Display placeholder of the form item.
     * @param formValue the form value hash.
     */
    placeholder?: FdkAsyncProperty<string> | ((formValue?: DynamicFormValue) => FdkAsyncProperty<string>);
    /**
     * @description
     * If true, the form item will be displayed as readonly.
     */
    readonly?: boolean;
    /**
     * @description
     * If true, will fall back to `message` property if `placeholder` was not provided.
     */
    useMessageAsPlaceholder?: boolean;
    /**
     * @description
     * Default value of the form item.
     */
    default?: FdkAsyncProperty<T> | ((formValue?: DynamicFormValue) => FdkAsyncProperty<T>);
    /**
     * @description
     * Receive the user input and form value hash.
     * Should return null if the value is valid, and an error message (String) or `false` otherwise.
     * If `false` is returned, a default error message is provided.
     * @param formItemValue raw form item value.
     * @param formValue the form value hash.
     * @returns null or String
     */
    validate?: (formItemValue: T, formValue?: DynamicFormValue) => DynamicFormItemValidationResult | Promise<DynamicFormItemValidationResult> | Observable<DynamicFormItemValidationResult>;
    /**
     * @description
     * The list of validators applied to the form item.
     */
    validators?: ValidatorFn[] | null;
    /**
     * @description
     * The list of async validators applied to the form item.
     */
    asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null;
    /**
     * @description Set when form item is a mandatory one.
     */
    required?: boolean;
    /**
     * @description Transforms raw form item value.
     * @param formItemValue raw form item value.
     * @param formValue the form value hash.
     * @param formItem @see DynamicFormFieldItem
     * @returns updated form item value to be used in the form value hash.
     */
    transformer?: (formItemValue: T, formValue?: DynamicFormValue, formItem?: DynamicFormFieldItem) => any | Promise<any>;
    /**
     * @description Transforms raw form item value for render purposes.
     * @param formItemValue raw form item value.
     * @param formValue the form value hash.
     * @param formItem @see DynamicFormFieldItem
     * @returns updated form item value to be used in the form value hash for rendering purposes.
     */
    valueRenderer?: (formItemValue: T, formValue?: DynamicFormValue, formItem?: DynamicFormFieldItem) => any | Promise<any>;
    /**
     * @description Should return true or false depending on whether this form item should be asked.
     * @param formValue the form value hash.
     * @param forms All available forms stored in form generator service.
     * @param control Dynamic form control.
     * @returns Boolean
     */
    when?: (formValue: DynamicFormValue, forms: Map<string, DynamicFormGroup>, control: DynamicFormGroupControl) => boolean | Promise<boolean> | Observable<boolean>;
    /**
     * @description Callback function that is triggered after field value has been changed.
     * @param fieldValue Field value.
     * @param forms All available forms stored in form generator service.
     * @param control Dynamic form control.
     */
    onchange?: (fieldValue: T, forms: Map<string, DynamicFormGroup>, control: DynamicFormControl) => void | Promise<void> | Observable<void>;
    /**
     * @hidden
     * @description
     * Used as a static flag on should this form item be shown.
     */
    shouldShow?: boolean;
    /**
     * @description
     * Rank is used for ordering.
     * Than lower number then higher priority.
     */
    rank?: number;
    /**
     * @description
     * Additional set of options that can affect UI of the form item form control.
     */
    guiOptions?: DynamicFormItemGuiOptions;
}
interface InputDynamicFormFieldItem extends BaseDynamicFormFieldItem<string> {
    type: 'input' | 'email' | 'number' | 'password';
    /**
     * @description
     * Additional set of options that can affect UI of the form item form control.
     */
    controlType?: InputType;
}
interface DatePickerDynamicFormFieldItem extends BaseDynamicFormFieldItem<FdDate> {
    type: 'datepicker';
}
interface TextAreaDynamicFormFieldItem extends BaseDynamicFormFieldItem<string> {
    type: 'editor' | 'textarea';
}
interface SwitchDynamicFormFieldItem extends BaseDynamicFormFieldItem<boolean> {
    type: 'switch';
}
interface SelectDynamicFormFieldItem<T = DynamicFormItemChoiceTypes<any>> extends BaseDynamicFormFieldItem<T> {
    type: 'select' | 'list' | 'multi-input';
    /**
     * @description
     * The list of available options to select.
     * @param formValue raw form item value.
     */
    choices?: DynamicFormItemChoice | ((formValue?: DynamicFormValue) => DynamicFormItemChoice);
    secondaryKey?: string;
    /** Show the second column (Applicable for two columns layout) */
    showSecondaryText?: boolean;
    /** Horizontally align text inside the second column (Applicable for two columns layout) */
    secondaryTextAlignment?: TextAlignment;
    /** Custom template used to build control body. */
    controlTemplate?: TemplateRef<any>;
}
interface RadioDynamicFormFieldItem extends Omit<SelectDynamicFormFieldItem<any>, 'type'> {
    type: 'radio' | 'confirm';
}
interface CheckboxDynamicFormFieldItem extends Omit<SelectDynamicFormFieldItem<any>, 'type'> {
    type: 'checkbox';
}
interface ObjectStatusDynamicFormFieldItem extends BaseDynamicFormFieldItem<string> {
    type: 'object-status';
    guiOptions?: BaseDynamicFormFieldItem['guiOptions'] & {
        status?: ObjectStatus;
        icon?: string;
        indicationColor?: ColorAccent;
    };
}
interface AnyDynamicFormFieldItem<T = any> extends BaseDynamicFormFieldItem<T> {
    type: string;
    /**
     * @description
     * The list of available options to select.
     * @param formValue raw form item value.
     */
    choices?: DynamicFormItemChoice | ((formValue?: DynamicFormValue) => DynamicFormItemChoice);
}
type DynamicFormFieldItem<T extends Record<string, any> = Record<string, any>, U extends BaseDynamicFormFieldItem = AnyDynamicFormFieldItem> = T & (InputDynamicFormFieldItem | DatePickerDynamicFormFieldItem | TextAreaDynamicFormFieldItem | SwitchDynamicFormFieldItem | SelectDynamicFormFieldItem | RadioDynamicFormFieldItem | CheckboxDynamicFormFieldItem | ObjectStatusDynamicFormFieldItem | U | AnyDynamicFormFieldItem);
type PreparedDynamicFormFieldItemFields = {
    message: string;
    default: any;
    placeholder?: string;
    choices?: SelectItem[];
    readonly?: boolean;
};
/**
 * @hidden
 * Internal representation of DynamicFormFieldItem with all fields resolved to a plain value
 */
type PreparedDynamicFormFieldItem<T extends BaseDynamicFormFieldItem = BaseDynamicFormFieldItem> = Omit<T, keyof PreparedDynamicFormFieldItemFields> & PreparedDynamicFormFieldItemFields;
interface BaseDynamicFormItemGuiOptions {
    /**
     * @description
     * Defines label's column layout.
     */
    labelColumnLayout?: ColumnLayout;
    /**
     * @description
     * Defines field's column layout.
     */
    fieldColumnLayout?: ColumnLayout;
    /**
     * @description
     * Defines gap column layout.
     */
    gapColumnLayout?: ColumnLayout;
    /**
     * @description
     * If set, hint icon is added to control label or group heading with tooltip message as a value.
     */
    hint?: HintInput;
}
interface DynamicFormItemGuiOptions extends BaseDynamicFormItemGuiOptions {
    /**
     * @description
     * Index of column if form has multi-column layout.
     */
    column?: number;
    /**
     * @description
     * Column arrangement for form-field based on screen size.
     */
    columnLayout?: ColumnLayout;
    /**
     * @description
     * Inline layout for list based form item.
     */
    inlineLayout?: InlineLayout;
    /**
     * @description
     * Flag indicating that label should be hidden.
     */
    noLabelLayout?: boolean;
    /**
     * @description
     * If set, controls inner elements will be inlined.
     */
    inline?: boolean;
    /**
     * @description
     * If set, overrides current content density of the element defined on the global scope.
     */
    contentDensity?: ContentDensity;
    /**
     * @description Object contains additional payload. Useful for custom elements to manipulate it's view.
     */
    additionalData?: any;
    /**
     * @description
     * If label should be appended with colon. True by default.
     */
    appendColon?: boolean;
    /**
     * Hint options. Either only text or full config
     */
    hint?: FieldHintInput;
}
type DynamicFormValue = Record<string, any>;

interface DynamicAbstractControlOptions extends AbstractControlOptions {
    dynamicFormItem: PreparedDynamicFormFieldItem;
}

type DynamicFormGroupControl = DynamicFormControl | DynamicFormControlGroup;
interface DynamicFormGroupControls {
    [key: string]: DynamicFormGroupControl;
}
declare class DynamicFormControlGroup extends FormGroup {
    /** @hidden */
    formItem: DynamicFormFieldGroupMap;
    /** @hidden */
    type: string;
    /** @hidden */
    controls: DynamicFormGroupControls;
    /** @hidden */
    constructor(formItem: DynamicFormFieldGroupMap, controls: DynamicFormGroupControls, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
}
declare class DynamicFormControl extends FormControl {
    /** @hidden */
    formItem: PreparedDynamicFormFieldItem;
    /** @hidden */
    type: string;
    /**
     * @description Creates a new `DynamicFormControl` instance.
     *
     * @param formState Initializes the control with an initial value,
     * or an object that defines the initial value and disabled state.
     *
     * @param validatorOrOpts A synchronous validator function, or an array of
     * such functions, or an `AbstractControlOptions` object that contains validation functions
     * and a validation trigger.
     *
     * @param asyncValidator A single async validator or array of async validator functions
     *
     * @param formItem `DynamicFormItem` object
     *
     */
    constructor(formState: any, validatorOrOpts: DynamicAbstractControlOptions);
}

interface BaseDynamicFormGeneratorControlInterface {
    formItem: PreparedDynamicFormFieldItem;
    name: string;
    id: string;
    form: FormGroup;
    formField: PlatformFormField;
}
/**
 * Abstract class that used as a base for the Dynamic Form Generator components.
 */
declare abstract class BaseDynamicFormGeneratorControl<T extends BaseDynamicFormFieldItem = BaseDynamicFormFieldItem> implements BaseDynamicFormGeneratorControlInterface {
    /**
     * @description @see DynamicFormItem.
     */
    formItem: PreparedDynamicFormFieldItem<T>;
    /**
     * @description Id of the control.
     */
    id: string;
    /**
     * @description Represents form control name.
     */
    name: string;
    /**
     * @description Reference to the @see FormGroup class.
     */
    form: FormGroup;
    /**
     * @description Reference to the @see FormFieldComponent.
     */
    formField: PlatformFormField;
    /** @description Inner form group name */
    formGroupName: string;
    /** @description Returns form item choices. */
    get choices(): SelectItem[];
    /** @description Returns form item placeholder. */
    get placeholder(): string;
    /** @hidden */
    get readonly(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDynamicFormGeneratorControl<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseDynamicFormGeneratorControl<any>, never, never, { "formItem": { "alias": "formItem"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "form": { "alias": "form"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; "formGroupName": { "alias": "formGroupName"; "required": false; }; }, {}, never, never, true, never>;
}

interface FormComponentDefinition {
    types?: string[];
    component: Type<BaseDynamicFormGeneratorControl>;
}

/**
 * Since form generator service most probably will be provided by parent component,
 * so that forms map does not interfere with other form generators,
 * Components Accessor is a separate service with a global scope, which can be also provided per component.
 */
declare class FormGeneratorComponentsAccessorService {
    /**
     * @hidden
     */
    private _formComponentDefinitions;
    /**
     * @description Adds custom component to the list of available components for the form generator items.
     * @param component Angular component.
     * @param types types of the form item.
     */
    addComponent(component: Type<BaseDynamicFormGeneratorControl>, types: string[]): boolean;
    /**
     * @description Returns best-matched component based on provided `type` argument
     * @param type form item type
     * @returns @see FormComponentDefinition Component definition for the form item
     */
    getComponentDefinitionByType(type: string): FormComponentDefinition | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormGeneratorComponentsAccessorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormGeneratorComponentsAccessorService>;
}

interface FormGeneratorConfig {
    /**
     * Control names separator for multidimensional forms.
     */
    controlNameSeparator: string;
    /**
     * Name of the group which holds all ungrouped controls.
     */
    ungroupedControlsName: string;
}
interface FormGeneratorModuleConfig {
    /**
     * Default configuration of the form generator item.
     */
    itemConfig?: Partial<DynamicFormFieldItem>;
    /**
     * Default configuration of the form generator form.
     */
    formConfig?: Partial<FormGeneratorConfig>;
}

/**
 * @description Form generator service
 */
declare class FormGeneratorService {
    private _fb;
    private _componentsAccessor;
    private _defaultItemConfig;
    private _providedConfig;
    /**
     * Map of generated forms to access later.
     */
    readonly forms: Map<string, DynamicFormGroup>;
    /**
     * Predefined validation error messages.
     */
    validationErrorHints: {
        required: string;
        validator: string;
    };
    /** @hidden */
    private readonly _config;
    /**
     * @hidden
     * An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)
     */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_fb: FormBuilder, _componentsAccessor: FormGeneratorComponentsAccessorService, _defaultItemConfig: Partial<DynamicFormFieldItem>, _providedConfig: Partial<FormGeneratorConfig>);
    /**
     * @description Generates `FormGroup` class with the list of `DynamicFormControl` control classes
     * defined in `formItems` argument.
     * @param formName Form name.
     * @param formItems the list of form items which used for form control generation.
     * @returns `FormGroup` class with the list of `DynamicFormControl` control classes.
     */
    generateForm(formName: string, formItems: Map<string, DynamicFormItemMap>): Promise<DynamicFormGroup>;
    /**
     * Adds new control to a form.
     * @param control Control to add
     * @param form Form of the control to be added.
     * @param path Group path.
     */
    addControl(control: DynamicFormItem, form: DynamicFormGroup, path?: string[]): Promise<void>;
    /**
     * Removes the control with given name from the form.
     * @param controlName
     * @param path
     */
    removeControl(controlName: string, form: DynamicFormGroup, path?: string[]): void;
    /**
     * @description Returns form value with applied filters and transformers.
     * @param form Form generator form
     * @param renderValue Whether or not form value will be used for rendering purposes.
     * @returns form value object.
     */
    getFormValue(form: DynamicFormGroup | DynamicFormControlGroup, renderValue?: boolean): Promise<DynamicFormValue>;
    /**
     * @description Adds custom component to the list of available components for the form generator items.
     * @param component Angular component.
     * @param types types of the form item.
     */
    addComponent(component: Type<BaseDynamicFormGeneratorControl>, types: string[]): boolean;
    /**
     * @description Returns best-matched component based on provided `type` argument
     * @param type form item type
     * @returns @see FormComponentDefinition Component definition for the form item
     */
    getComponentDefinitionByType(type: string): FormComponentDefinition | undefined;
    /**
     * @returns Object of available errors, where key is an error type,
     * and it's value is a display text.
     */
    getValidationErrorHints(key: string): string;
    /**
     * @description Adds custom error hint defined by user.
     * @param type error type from validator.
     * @param value display text.
     */
    addValidationErrorHint(type: string, value: string): void;
    /**
     * @description Checks if some items of the form should be hidden,
     * or visible based on `when` method result.
     * @param form
     * @returns `Set` where key is item name, and boolean value if field needs to be shown.
     */
    checkVisibleFormItems(form: DynamicFormGroup): Promise<{
        [key: string]: boolean;
    }>;
    /**
     * Method for searching a form control inside form group. Can also search inside ungrouped form group.
     * @param form Form group.
     * @param controlNames Name of the form control.
     * @returns Found form control.
     */
    getFormControl(form: DynamicFormGroup, ...controlNames: string[]): DynamicFormGroupControl;
    /** Resets the form to it's initial state. */
    resetForm(form: DynamicFormGroup): void;
    /** @hidden */
    _getFormValueWithoutUngrouped(value: any): any;
    /** @hidden */
    private _assignFormItemValidators;
    /** @hidden */
    private _generateDynamicFormItem;
    /** @hidden */
    private _checkFormControlsVisibility;
    /**
     * @hidden
     * @param formItem
     * @param form
     * @param key
     * @returns
     */
    private _getFormItemPropertyValue;
    /** @hidden */
    private _getFormItemProperties;
    /**
     * @hidden
     * @param formItem
     * @param form
     * @returns
     */
    private _getFormItemChoices;
    /**
     * @hidden
     * @description Returns value from Promise-like, Observable-like, simple function or just some object.
     * @param obj
     * @returns
     */
    private _getFunctionValue;
    /** @hidden */
    private _formatPasswordValue;
    /** @hidden */
    private _getMergedFormFieldItemConfig;
    /** @hidden */
    private _transformFormItems;
    /** @hidden */
    private _triggerFieldsOnchange;
    /** @hidden */
    private _cloneOldFormGroup;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormGeneratorService, [null, null, { optional: true; skipSelf: true; }, { optional: true; skipSelf: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormGeneratorService>;
}

declare class FormGeneratorFieldComponent implements OnInit {
    private _fgService;
    /**
     * Form control.
     */
    field: DynamicFormControl;
    /**
     * Form generator's form.
     */
    form: DynamicFormGroup;
    /**
     * Translations template reference.
     */
    i18n: TemplateRef<any>;
    /**
     * Form control name
     */
    formFieldName: string;
    /**
     * Path of the form group.
     */
    formGroupNamePath: string;
    /**
     * Rank is used for ordering.
     * The lower number the higher priority.
     */
    rank: number;
    /**
     * Whether this field should be visible.
     */
    shouldShow: boolean;
    /**
     * Describes hint options for field label
     */
    hintOptions?: FieldHintOptions;
    /**
     * Form field component.
     */
    fieldRenderer: PlatformFormField;
    /** @hidden */
    get _placeholder(): string;
    /** @hidden */
    _errorModels: {
        type: string;
        value: any;
    }[];
    /** @hidden */
    constructor(_fgService: FormGeneratorService);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    _errorsTrackBy(_: number, error: {
        type: string;
        value: any;
    }): string;
    /** @hidden */
    _isAdvancedError(error: any): error is DynamicFormItemValidationObject;
    /** @hidden */
    private _getErrors;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormGeneratorFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormGeneratorFieldComponent, "fdp-form-generator-field", never, { "field": { "alias": "field"; "required": false; }; "form": { "alias": "form"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; "formFieldName": { "alias": "formFieldName"; "required": false; }; "formGroupNamePath": { "alias": "formGroupNamePath"; "required": false; }; "rank": { "alias": "rank"; "required": false; }; "shouldShow": { "alias": "shouldShow"; "required": false; }; "hintOptions": { "alias": "hintOptions"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormFieldGroupComponent implements FormFieldGroup, OnInit, OnDestroy {
    /**
     * Group header title
     */
    label: string;
    /** Group's form name */
    formName: string;
    /**
     * Form Group Container to bind the Form-Field-Group to.
     * This will override default value injected by constructor
     */
    formGroupContainer: FormGroupContainer | null;
    /**
     * Defines label's column layout.
     */
    set labelColumnLayout(value: ColumnLayout | undefined);
    get labelColumnLayout(): ColumnLayout;
    /**
     * Defines field's column layout.
     */
    set fieldColumnLayout(value: ColumnLayout | undefined);
    get fieldColumnLayout(): ColumnLayout;
    /**
     * Defines gap column layout.
     */
    set gapColumnLayout(value: ColumnLayout | undefined);
    get gapColumnLayout(): ColumnLayout;
    /**
     * Describes hint options for group header
     */
    hintOptions?: HintOptions;
    /**
     * Get form fields wrapped into form field group
     */
    fields: QueryList<PlatformFormField>;
    /** @hidden */
    private _labelColumnLayout;
    /** @hidden */
    private _fieldColumnLayout;
    /** @hidden */
    private _gapColumnLayout;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _setDefaultLayout;
    /** @hidden */
    private _addToFormGroup;
    /** @hidden */
    private _removeFromFormGroup;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldGroupComponent, "fdp-form-field-group", never, { "label": { "alias": "label"; "required": false; }; "formName": { "alias": "formName"; "required": false; }; "formGroupContainer": { "alias": "formGroupContainer"; "required": false; }; "labelColumnLayout": { "alias": "labelColumnLayout"; "required": false; }; "fieldColumnLayout": { "alias": "fieldColumnLayout"; "required": false; }; "gapColumnLayout": { "alias": "gapColumnLayout"; "required": false; }; "hintOptions": { "alias": "hintOptions"; "required": false; }; }, {}, ["fields"], ["*"], true, never>;
}

interface FieldColumn {
    [key: number]: Array<Field>;
}
declare class Field {
    name?: string | undefined;
    rank?: number | undefined;
    renderer?: TemplateRef<any> | undefined;
    column?: number | undefined;
    /** @hidden */
    constructor(name?: string | undefined, rank?: number | undefined, renderer?: TemplateRef<any> | undefined, column?: number | undefined);
}
declare class FieldGroup {
    label: string;
    fields: FieldColumn;
    hintOptions?: HintOptions | undefined;
    /** @hidden */
    constructor(label: string, fields: FieldColumn, hintOptions?: HintOptions | undefined);
}

/** @hidden */
declare function isFieldChild(child: unknown): child is PlatformFormField;
/** @hidden */
declare function isFieldGroupWrapperChild(child: unknown): child is FormGeneratorFieldComponent;
/** @hidden */
declare function isFieldGroupChild(child: unknown): child is FormFieldGroupComponent;
/** @hidden */
declare function getFormField(field: PlatformFormField | FormGeneratorFieldComponent): PlatformFormField;
/** @hidden */
declare function getField(field: PlatformFormField): Field;

/**
 * Returns form state based on priority.
 * @param states Error states of the form fields.
 * @param priorityStates Array of prioritized states.
 * @returns first found form state of `priorityStates`.
 */
declare function getFormState(states: FormStates[], priorityStates?: FormStates[]): FormStates;

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformAutoCompleteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformAutoCompleteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformAutoCompleteModule, never, [typeof AutoCompleteDirective], [typeof AutoCompleteDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformAutoCompleteModule>;
}

/** Change event object emitted by Platform Checkbox. */
declare class PlatformCheckboxChange {
    /** The source Checkbox of the event. */
    source: CheckboxComponent;
    /**
     * The new `checked` value of the checkbox.
     * possible value: true/false and array of checkbox values.
     */
    checked: any;
}
declare class CheckboxComponent extends BaseInput implements AfterViewInit {
    tabIndexValue: number;
    /**
     * Checkbox tooltip
     */
    title: string;
    /** Sets label for checkbox. */
    label: string;
    /** true when checkbox has indeterminate state */
    tristate: boolean;
    /**
     * Checked state of the checkbox control.
     */
    set value(selectValue: any);
    get value(): any;
    /** when true indeterminate state can be selected */
    tristateSelectable: boolean;
    /** Values returned by control. */
    values: FdCheckboxValues;
    /** Whether checkbox should be rendered standalone (without any text). */
    standalone: boolean;
    /** Whether the checkbox should be rendered in display-only mode. */
    displayOnly: boolean;
    /**
     * Emitting checked event for non-form checkbox
     */
    readonly checkedChange: EventEmitter<any>;
    /**
     * @hidden
     * is needed for the checkbox group to access component values
     */
    coreCheckbox: CheckboxComponent$1;
    /** @hidden */
    constructor(tabIndexValue?: number);
    /** update controller on checkbox state change */
    onModelChange(value: any): void;
    /**
     * Method to emit change event
     */
    private _emitChangeEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, [{ attribute: "tabIndexValue"; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "fdp-checkbox", never, { "title": { "alias": "title"; "required": false; }; "label": { "alias": "label"; "required": false; }; "tristate": { "alias": "tristate"; "required": false; }; "value": { "alias": "checked"; "required": false; }; "tristateSelectable": { "alias": "tristateSelectable"; "required": false; }; "values": { "alias": "values"; "required": false; }; "standalone": { "alias": "standalone"; "required": false; }; "displayOnly": { "alias": "displayOnly"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformCheckboxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformCheckboxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformCheckboxModule, never, [typeof CheckboxComponent], [typeof CheckboxComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformCheckboxModule>;
}

/**
 * Checkbox group implementation based on the
 * https://github.com/SAP/fundamental-ngx/wiki/Platform:-CheckboxGroup-Technical-Design
 * documents.
 */
declare class CheckboxGroupComponent extends InLineLayoutCollectionBaseInput {
    /**
     * value for selected checkboxes.
     */
    set value(selectedValue: any[]);
    get value(): any[];
    /**
     * To Display multiple checkboxes in a line
     */
    set isInline(inline: boolean);
    get isInline(): boolean;
    /** Children checkboxes passed as content */
    contentCheckboxes: QueryList<CheckboxComponent>;
    /** Children checkboxes created from passed list values. */
    viewCheckboxes: QueryList<CheckboxComponent>;
    /** Emits checked change event */
    readonly valueChange: EventEmitter<string[]>;
    /** @hidden */
    readonly _selectionModel: SelectionModel<unknown>;
    /** @hidden */
    private readonly _rangeSelector;
    /**
     * @hidden
     * @param selectionState actual value of the checkbox
     * @param checkboxTrueValue thuthy value to compare the "selectionState" with
     */
    onModelChanged(selectionState: any, checkboxTrueValue: any): void;
    /** @hidden */
    onCheckboxClick(index: number, source: 'contentChildren' | 'list', event?: MouseEvent): void;
    /** @hidden */
    writeValue(selectedValue: any): void;
    /**
     * access display value for objects, acts as checkbox label.
     */
    getDisplayValue(item: any): string;
    /**
     * access lookup value for objects, acts as checkbox value.
     */
    getLookupValue(item: any): string;
    /** @hidden */
    getListItemDisabledValue(item: CheckboxGroupComponent['list'][number]): boolean;
    /** @inheritdoc */
    protected setValue(value: any, emitOnChange?: boolean): void;
    /** @hidden */
    private _setValueBySelectionModel;
    /** @hidden */
    private _updateSelectionModelByValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxGroupComponent, "fdp-checkbox-group", never, { "value": { "alias": "value"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; }, { "valueChange": "valueChange"; }, ["contentCheckboxes"], never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformCheckboxGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformCheckboxGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformCheckboxGroupModule, never, [typeof CheckboxGroupComponent], [typeof CheckboxGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformCheckboxGroupModule>;
}

/**
 * The Platform date picker component is a wrapper around fd-date-picker using platform form.
 * It is able to provide form field functionalities as well along with fd-date-picker functions.
 *
 * <fdp-form-group #ffg [formGroup]="datePickerForm">
 *      <fdp-form-field #ffl1 id="birthday">
 *          <fdp-date-picker name="birthday" type="single" [formControl]="ffl1.formControl"></fdp-date-picker>
 *      </fdp-form-field>
 * </fdp-form-group>
 *
 */
declare class PlatformDatePickerComponent<D> extends BaseInput {
    /**
     * date-picker value set as controller value
     */
    set value(value: D | Array<D> | DateRange<D> | Array<DateRange<D>>);
    get value(): DateRange<D> | D;
    /** below code taken from core/date-picker */
    /** The type of calendar, 'single' for single date selection or 'range' for a range of dates. */
    type: CalendarType;
    /** The currently selected date model in single mode. */
    selectedDate: Nullable<D>;
    /** The currently selected date model in multiple mode. */
    selectedMultipleDates: Array<D>;
    /** The currently selected date model with start and end in range mode. */
    selectedRangeDate: DateRange<D>;
    /** The currently selected date model with multiple ranges. */
    selectedMultipleDateRanges: Array<DateRange<D>>;
    /** The day of the week the calendar should start on. 1 represents Sunday, 2 is Monday, 3 is Tuesday, and so on. */
    startingDayOfWeek: DaysOfWeek;
    /**
     * Whether user wants to mark day cells on hover.
     * Works only on range mode, when start date is selected on Day View.
     */
    rangeHoverEffect: boolean;
    /** Whether to validate the date picker input. */
    useValidation: boolean;
    /** Enables Today-Selection-Button if true */
    showTodayButton: boolean;
    /** Label for Today-Selection-Button */
    todayButtonLabel: string;
    /** Whether a null input is considered valid. */
    allowNull: boolean;
    /** Actually shown active view one of 'day' | 'month' | 'year' in calendar component*/
    activeView: FdCalendarView;
    /**
     *  The placement of the popover. It can be one of: top, top-start, top-end, bottom,
     *  bottom-start, bottom-end, right, right-start, right-end, left, left-start, left-end.
     */
    placement: Placement;
    /** The element to which the popover should be appended. */
    appendTo: ElementRef;
    /** Defines if date picker should be closed after date choose */
    closeOnDateChoose: boolean;
    /**
     *  The state of the form control - applies css classes.
     *  Can be `success`, `error`, `warning`, `information` or blank for default.
     */
    set state(state: FormStates);
    get state(): FormStates;
    /**
     * Whether AddOn Button should be focusable
     * @default true
     */
    buttonFocusable: boolean;
    /**
     * Special days mark, it can be used by passing array of object with
     * Special day number, list 1-20 [class:`fd-calendar__item--legend-{{number}}`] is available there:
     * https://sap.github.io/fundamental-styles/components/calendar.html calendar special days section
     * Rule accepts method with FdDate object as a parameter. ex:
     * `rule: (fdDate: FdDate) => fdDate.getDay() === 1`, which will mark all sundays as special day.
     */
    specialDaysRules: SpecialDayRule<D>[];
    /**
     * Object to customize year grid,
     * Row, Columns and method to display year can be modified
     */
    yearGrid: CalendarYearGrid;
    /**
     * Object to customize aggregated year grid,
     * Row, Columns and method to display year can be modified
     */
    aggregatedYearGrid: CalendarYearGrid;
    /**
     * Whether user wants to mark sunday/saturday with `fd-calendar__item--weekend` class
     */
    markWeekends: boolean;
    /**
     * Whether user wants to show week numbers next to days
     */
    showWeekNumbers: boolean;
    /**
     * Whether the user wants to select multiple days or multiple range dates.
     * If `displayWeekNumbers` is true, the user can click on the week number to mark the related row.
     * The user can click on week days to mark the related column.
     * Note: Clickable selection for week row or column does not work for range selections.
     */
    allowMultipleSelection: boolean;
    /** Whether the date picker is open. Can be used through two-way binding. */
    isOpen: boolean;
    /** Should date picker be inlined. */
    inline: boolean;
    /**
     * Whether to recalculate value from the input as user types or on blur.
     * By default, updates the value as user types.
     * @default false
     */
    processInputOnBlur: boolean;
    /**
     * Whether to prevent page scrolling when focusing date picker input field after calendar has been closed.
     */
    preventScrollOnFocus: boolean;
    /** Whether date picker should rendered in mobile mode. */
    mobile: boolean;
    /** Mobile mode configuration. */
    mobileConfig: MobileModeConfig;
    /** Whether calendar is used inside mobile in landscape mode, it also adds close button on right side */
    mobileLandscape: boolean;
    /** Whether calendar is used inside mobile in portrait mode */
    mobilePortrait: boolean;
    /** Event emitted when the state of the isOpen property changes. */
    readonly isOpenChange: EventEmitter<boolean>;
    /** Event thrown every time selected date in single mode is changed */
    readonly selectedDateChange: EventEmitter<Nullable<D>>;
    /** Event thrown every time the selected dates in multiple mode are changed. */
    readonly selectedMultipleDatesChange: EventEmitter<Array<D>>;
    /** Event thrown every time selected first or last date in range mode is changed */
    readonly selectedRangeDateChange: EventEmitter<DateRange<D>>;
    /** Event thrown every time the first or last date in multiple range mode is changed. */
    readonly selectedMultipleDateRangesChange: EventEmitter<Array<DateRange<D>>>;
    /** Event thrown every time calendar active view is changed */
    readonly activeViewChange: EventEmitter<FdCalendarView>;
    /**
     * @hidden core date-picker as child
     */
    fdDatePickerComponent: DatePickerComponent<D>;
    /**
     * Whether to show the calendar legend for special days.
     * When enabled, displays a legend below the calendar showing the special day markers and their descriptions.
     * @default false
     */
    showCalendarLegend: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether to display the calendar legend in column layout.
     * When true, legend items are displayed vertically in a single column.
     * When false, legend items are displayed horizontally in rows.
     * @default false
     */
    legendCol: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    private _datePickerValid;
    /** @hidden */
    private readonly _dateTimeAdapter;
    /** @hidden */
    private readonly _dateTimeFormats;
    /** @hidden */
    constructor();
    /**
     * Function used to disable certain dates in the calendar.
     */
    disableFunction: (value: D) => boolean;
    /**
     * Function used to disable certain dates in the calendar for the range start selection.
     */
    disableRangeStartFunction: (value: D) => boolean;
    /**
     * Function used to disable certain dates in the calendar for the range end selection.
     */
    disableRangeEndFunction: (value: D) => boolean;
    /** @hidden */
    writeValue(value: D | Array<D> | DateRange<D> | Array<DateRange<D>> | null): void;
    /**
     * validates date on date change.
     * @param value D | DateRange<D>
     */
    handleDateChange(value: D | Array<D> | DateRange<D> | Array<DateRange<D>>): void;
    /**
     * Method that handles changes when popover is opened or closed.
     */
    handleOpenChange: (open: boolean) => void;
    /** @hidden */
    handleSelectedDateChange: (fdDate: Nullable<D>) => void;
    /** @hidden */
    handleSelectedMultipleDatesChange: (fdDate: Array<D>) => void;
    /** @hidden */
    handleSelectedRangeDateChange: (fdRangeDate: DateRange<D>) => void;
    /** @hidden */
    handleSelectedMultipleDateRangesChange: (fdRangeDate: Array<DateRange<D>>) => void;
    /** @hidden */
    handleActiveViewChange: (fdCalendarView: FdCalendarView) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformDatePickerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformDatePickerComponent<any>, "fdp-date-picker", never, { "value": { "alias": "value"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "selectedMultipleDates": { "alias": "selectedMultipleDates"; "required": false; }; "selectedRangeDate": { "alias": "selectedRangeDate"; "required": false; }; "selectedMultipleDateRanges": { "alias": "selectedMultipleDateRanges"; "required": false; }; "startingDayOfWeek": { "alias": "startingDayOfWeek"; "required": false; }; "rangeHoverEffect": { "alias": "rangeHoverEffect"; "required": false; }; "useValidation": { "alias": "useValidation"; "required": false; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; }; "todayButtonLabel": { "alias": "todayButtonLabel"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "closeOnDateChoose": { "alias": "closeOnDateChoose"; "required": false; }; "state": { "alias": "state"; "required": false; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; }; "specialDaysRules": { "alias": "specialDaysRules"; "required": false; }; "yearGrid": { "alias": "yearGrid"; "required": false; }; "aggregatedYearGrid": { "alias": "aggregatedYearGrid"; "required": false; }; "markWeekends": { "alias": "markWeekends"; "required": false; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; }; "allowMultipleSelection": { "alias": "allowMultipleSelection"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "processInputOnBlur": { "alias": "processInputOnBlur"; "required": false; }; "preventScrollOnFocus": { "alias": "preventScrollOnFocus"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "mobileLandscape": { "alias": "mobileLandscape"; "required": false; }; "mobilePortrait": { "alias": "mobilePortrait"; "required": false; }; "showCalendarLegend": { "alias": "showCalendarLegend"; "required": false; "isSignal": true; }; "legendCol": { "alias": "legendCol"; "required": false; "isSignal": true; }; "disableFunction": { "alias": "disableFunction"; "required": false; }; "disableRangeStartFunction": { "alias": "disableRangeStartFunction"; "required": false; }; "disableRangeEndFunction": { "alias": "disableRangeEndFunction"; "required": false; }; }, { "isOpenChange": "isOpenChange"; "selectedDateChange": "selectedDateChange"; "selectedMultipleDatesChange": "selectedMultipleDatesChange"; "selectedRangeDateChange": "selectedRangeDateChange"; "selectedMultipleDateRangesChange": "selectedMultipleDateRangesChange"; "activeViewChange": "activeViewChange"; }, never, ["*"], true, never>;
}
/** @hidden */
declare function createMissingDateImplementationError(provider: string): Error;

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformDatePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformDatePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformDatePickerModule, never, [typeof PlatformDatePickerComponent], [typeof PlatformDatePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformDatePickerModule>;
}

declare class PlatformDatetimePickerComponent<D> extends BaseInput implements AfterViewInit {
    /**
     * value for datetime
     */
    set value(value: D);
    get value(): D;
    /**
     *  The placement of the popover. It can be one of: top, top-start, top-end, bottom,
     *  bottom-start, bottom-end, right, right-start, right-end, left, left-start, left-end.
     */
    placement: Placement;
    /** The element to which the popover should be appended. */
    appendTo: ElementRef;
    /**
     * Whether the time component should be meridian (am/pm).
     * Default value is based on the current locale format option
     * */
    meridian: boolean;
    /**
     * Whether the time component shows seconds.
     * Default value is based on the current locale format option
     * */
    displaySeconds: boolean;
    /**
     * Whether the time component shows minutes.
     * Default value is based on the current locale format option
     * */
    displayMinutes: boolean;
    /**
     * Whether the time component shows hours.
     * Default value is based on the current locale format option
     * */
    displayHours: boolean;
    /** Whether to perform visual validation on the picker input. */
    useValidation: boolean;
    /** Whether the popover is open. Two-way binding is supported. */
    isOpen: boolean;
    /** The starting day of week for the calendar. */
    startingDayOfWeek: DaysOfWeek;
    /** Actually shown active view one of 'day' | 'month' | 'year' in calendar component*/
    activeView: FdCalendarView;
    /** Whether a null input is considered valid. */
    allowNull: boolean;
    /**
     * @Input when set to true time component will use 2 digits for each number.
     * For example 9 will become 09
     * but 12 will be kept as 12.
     * Only uses by time component and does not change input format
     */
    keepTwoDigitsTime: boolean;
    /**
     *  The state of the form control - applies css classes.
     *  Can be `success`, `error`, `warning`, `information` or blank for default.
     */
    set state(state: FormStates | undefined);
    get state(): FormStates;
    /**
     * Whether AddOn Button should be focusable
     * @default true
     */
    buttonFocusable: boolean;
    /**
     * Special days mark, it can be used by passing array of object with
     * Special day number, list 1-20 [class:`fd-calendar__item--legend-{{number}}`] is available there:
     * https://sap.github.io/fundamental-styles/components/calendar.html calendar special days section
     * Rule accepts method with FdDate object as a parameter. ex:
     * `rule: (fdDate: FdDate) => fdDate.getDay() === 1`, which will mark all sundays as special day.
     */
    specialDaysRules: SpecialDayRule<D>[];
    /**
     * Object to customize year grid,
     * Row, Columns and method to display year can be modified
     */
    yearGrid: CalendarYearGrid;
    /**
     * Object to customize aggregated year grid,
     * Row, Columns and method to display year can be modified
     */
    aggregatedYearGrid: CalendarYearGrid;
    /**
     * Whether user wants to mark sunday/saturday with `fd-calendar__item--weekend` class
     */
    markWeekends: boolean;
    /** @Input Whether to show spinner buttons */
    spinnerButtons: boolean;
    /**
     * Whether user wants to show week numbers next to days
     */
    showWeekNumbers: boolean;
    /** Whether or not to show the datetime picker footer with submit/cancel buttons. */
    showFooter: boolean;
    /**
     * Whether to recalculate value from the input as user types or on blur.
     * By default, updates the value as user types.
     * @default false
     */
    processInputOnBlur: boolean;
    /**
     * Whether to prevent page scrolling when focusing date picker input field after calendar has been closed.
     */
    preventScrollOnFocus: boolean;
    /** Whether date picker should rendered in mobile mode. */
    mobile: boolean;
    /** Mobile mode configuration. */
    mobileConfig: MobileModeConfig;
    /** Whether calendar is used inside mobile in landscape mode, it also adds close button on right side */
    mobileLandscape: boolean;
    /** Whether calendar is used inside mobile in portrait mode */
    mobilePortrait: boolean;
    /** Event emitted when the state of the isOpen property changes. */
    readonly isOpenChange: EventEmitter<boolean>;
    /** Event thrown every time calendar active view is changed */
    readonly activeViewChange: EventEmitter<FdCalendarView>;
    /** Event emitted when the date changes. This can be a time or day change. */
    readonly datetimeChange: EventEmitter<D>;
    /** Event emitted when popover closes. */
    readonly onClose: EventEmitter<void>;
    /** @hidden */
    dateTimePickerComponent: DatetimePickerComponent<D>;
    /** @hidden */
    protected _elRef: ElementRef;
    /** @hidden */
    protected _control: NgControl;
    /**
     * Whether to show the calendar legend for special days.
     * When enabled, displays a legend below the calendar showing the special day markers and their descriptions.
     * @default false
     */
    showCalendarLegend: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether to display the calendar legend in column layout.
     * When true, legend items are displayed vertically in a single column.
     * When false, legend items are displayed horizontally in rows.
     * @default false
     */
    legendCol: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    get _isRequired(): boolean;
    /** @hidden */
    private readonly _dateTimeAdapter;
    /** @hidden */
    private readonly _dateTimeFormats;
    /** @hidden */
    constructor();
    /**
     * Function used to disable certain dates in the calendar.
     * @param fdDate FdDate
     */
    disableFunction: (value: D) => boolean;
    /**
     * @hidden
     */
    ngAfterViewInit(): void;
    /** @hidden */
    writeValue(value: D): void;
    /**
     * @hidden
     * override base functionality to catch new disabled state
     */
    setDisabledState(disabled: boolean): void;
    /**
     * @hidden
     * logic to handle validation from both platform forms and core datetiimepicker
     * @param datetime inputted
     */
    handleDatetimeInputChange(datetime: D): void;
    /**
     * Method that handles changes when popover is opened or closed.
     */
    handleOpenChange: (open: boolean) => void;
    /**
     * Method that handle calendar active view change and throws event.
     */
    handleActiveViewChange: (fdCalendarView: FdCalendarView) => void;
    /**
     * @hidden
     * method that adjusts width of datetimepicker to take 100% container space
     */
    private _adjustPickerWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformDatetimePickerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformDatetimePickerComponent<any>, "fdp-datetime-picker", never, { "value": { "alias": "value"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "meridian": { "alias": "meridian"; "required": false; }; "displaySeconds": { "alias": "displaySeconds"; "required": false; }; "displayMinutes": { "alias": "displayMinutes"; "required": false; }; "displayHours": { "alias": "displayHours"; "required": false; }; "useValidation": { "alias": "useValidation"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "startingDayOfWeek": { "alias": "startingDayOfWeek"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; "keepTwoDigitsTime": { "alias": "keepTwoDigitsTime"; "required": false; }; "state": { "alias": "state"; "required": false; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; }; "specialDaysRules": { "alias": "specialDaysRules"; "required": false; }; "yearGrid": { "alias": "yearGrid"; "required": false; }; "aggregatedYearGrid": { "alias": "aggregatedYearGrid"; "required": false; }; "markWeekends": { "alias": "markWeekends"; "required": false; }; "spinnerButtons": { "alias": "spinnerButtons"; "required": false; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "processInputOnBlur": { "alias": "processInputOnBlur"; "required": false; }; "preventScrollOnFocus": { "alias": "preventScrollOnFocus"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "mobileLandscape": { "alias": "mobileLandscape"; "required": false; }; "mobilePortrait": { "alias": "mobilePortrait"; "required": false; }; "showCalendarLegend": { "alias": "showCalendarLegend"; "required": false; "isSignal": true; }; "legendCol": { "alias": "legendCol"; "required": false; "isSignal": true; }; "disableFunction": { "alias": "disableFunction"; "required": false; }; }, { "isOpenChange": "isOpenChange"; "activeViewChange": "activeViewChange"; "datetimeChange": "datetimeChange"; "onClose": "onClose"; }, never, ["*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformDatetimePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformDatetimePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformDatetimePickerModule, never, [typeof PlatformDatetimePickerComponent], [typeof PlatformDatetimePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformDatetimePickerModule>;
}

declare const DEFAULT_COMPONENTS_LIST: FormComponentDefinition[];

declare const defaultFormGeneratorHintOptions: Omit<FieldHintOptions, 'content'>;

declare const DEFAULT_VALIDATION_ERRORS: {
    required: string;
    validator: string;
};

declare class DynamicFormGeneratorCheckboxComponent extends BaseDynamicFormGeneratorControl {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorCheckboxComponent, "fdp-dynamic-form-generator-checkbox", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorDatepickerComponent extends BaseDynamicFormGeneratorControl {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorDatepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorDatepickerComponent, "fdp-dynamic-form-generator-datepicker", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorEditorComponent extends BaseDynamicFormGeneratorControl {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorEditorComponent, "fdp-dynamic-form-generator-editor", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorInputComponent extends BaseDynamicFormGeneratorControl<InputDynamicFormFieldItem> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorInputComponent, "fdp-dynamic-form-generator-input", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorMultiInputComponent extends BaseDynamicFormGeneratorControl {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorMultiInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorMultiInputComponent, "fdp-dynamic-form-generator-multi-input", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorRadioComponent extends BaseDynamicFormGeneratorControl {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorRadioComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorRadioComponent, "fdp-dynamic-form-generator-radio", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorSelectComponent extends BaseDynamicFormGeneratorControl<SelectDynamicFormFieldItem> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorSelectComponent, "fdp-dynamic-form-generator-select", never, {}, {}, never, never, true, never>;
}

declare class DynamicFormGeneratorSwitchComponent extends BaseDynamicFormGeneratorControl {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorSwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorSwitchComponent, "fdp-dynamic-form-generator-switch", never, {}, {}, never, never, true, never>;
}

/**
 * @description
 * Structural directive, which hides current form item and toggles validation rules for it.
 */
declare class DynamicFormControlFieldDirective implements OnInit {
    private readonly _templateRef;
    private readonly _viewContainer;
    /**
     * @description Form control instance.
     */
    set fdpDynamicFormControlField(value: DynamicFormControl);
    /**
     * @description boolean flag representing if current item should be shown.
     */
    set fdpDynamicFormControlFieldShow(value: boolean);
    /**
     * @hidden
     */
    private _control;
    /**
     * @hidden
     */
    private _originalValidators?;
    /**
     * @hidden
     */
    private _originalAsyncValidators;
    /**
     * @hidden
     */
    private _componentRemoved;
    /**
     * @hidden
     */
    private _shouldShowFormItem;
    /** @hidden */
    constructor(_templateRef: TemplateRef<any>, _viewContainer: ViewContainerRef);
    /** @hidden */
    ngOnInit(): void;
    /**
     * @description If false, validation will be skipped from the form item control
     */
    set shouldShowFormItem(value: boolean);
    /** @hidden */
    private _updateView;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormControlFieldDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicFormControlFieldDirective, "[fdpDynamicFormControlField]", never, { "fdpDynamicFormControlField": { "alias": "fdpDynamicFormControlField"; "required": false; }; "fdpDynamicFormControlFieldShow": { "alias": "fdpDynamicFormControlFieldShow"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Dynamic form control directive represents a renderer of the dynamic components
 * based on the information provided in `formItem` input
 */
declare class DynamicFormControlDirective implements OnInit {
    private readonly _formGeneratorService;
    private readonly _vcRef;
    private readonly _injector;
    private contentDensityDirective;
    /**
     * @description @see DynamicFormItem
     */
    formItem: PreparedDynamicFormFieldItem;
    /**
     * @description Represents form control id.
     */
    id: string;
    /**
     * @description Represents form control name.
     */
    name: string;
    /**
     * @description Reference to the @see FormGroup class.
     */
    form: FormGroup;
    /** Form group name path */
    formGroupNamePath: string;
    /**
     * @description Reference to the @see FormFieldComponent
     */
    formField: PlatformFormField;
    /**
     * Control field instance.
     */
    formFieldControl: PlatformFormFieldControl;
    /** @hidden */
    constructor(_formGeneratorService: FormGeneratorService, _vcRef: ViewContainerRef, _injector: Injector, contentDensityDirective: Observable<ContentDensityMode>);
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormControlDirective, [null, null, null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicFormControlDirective, "[fdpDynamicFormControl]", never, { "formItem": { "alias": "formItem"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "form": { "alias": "form"; "required": false; }; "formGroupNamePath": { "alias": "formGroupNamePath"; "required": false; }; "formField": { "alias": "formField"; "required": false; }; }, {}, never, never, true, never>;
}

type FormGeneratorAcceptableItems = DynamicFormItem[] | Observable<DynamicFormItem[]>;
declare const FDP_FORM_IGNORED_STATUSES: FormControlStatus[];
interface SubmitFormEventResult {
    /**
     * @description Indicator if validation has been passed.
     */
    success: boolean;
    /**
     * @description Formatted form value.
     */
    value: DynamicFormValue | null;
}
/**
 * @description Form Generator component represents a high-level component
 * which includes @see FormGroup inside.
 */
declare class FormGeneratorComponent implements OnDestroy, OnChanges {
    private _fgService;
    private _cd;
    /** @description Unique form name */
    formName: string;
    /**
     * @description List of @see DynamicFormItem representing the list of items
     * to be rendered in the form.
     */
    set formItems(formItems: FormGeneratorAcceptableItems);
    get formItems(): FormGeneratorAcceptableItems;
    /**
     * @description Form main title.
     */
    mainTitle: Nullable<string>;
    /**
     * Whether to hide main title. Default is false.
     */
    hideMainTItle: boolean;
    /**
     * @description
     * Hint for the main title
     */
    hint: HintInput;
    /**
     * @description Specify the column layout in the format `XLn-Ln-Mn-Sn`
     * where n is the number of columns and can be different for each size.
     * eg: XL2-L2-M2-S1 would create 2-column layouts for XL, L,
     * and M sizes and single-column layout for S size.
     */
    columnLayout: Nullable<string>;
    /**
     * Defines label's column layout.
     */
    labelColumnLayout: ColumnLayout;
    /**
     * Defines field's column layout.
     */
    fieldColumnLayout: ColumnLayout;
    /**
     * Defines gap column layout.
     */
    gapColumnLayout: ColumnLayout;
    /** Whether all form items should have identical layout provided for form group. */
    unifiedLayout: boolean;
    /** Inline column layout */
    inlineColumnLayout: ColumnLayout;
    /**
     * @hidden
     * Removes extra empty row.
     * TODO: remove after #7533 has been fixed.
     */
    noAdditionalContent: boolean;
    /**
     * @description Event which notifies parent component that the form has been successfully created
     * and all controls are in place.
     */
    formCreated: EventEmitter<DynamicFormGroup>;
    /**
     * @description Event which notifies parent component that the form has been successfully validated
     * and submitted. Contains form
     */
    formSubmitted: EventEmitter<DynamicFormValue>;
    /**
     * @description Event which notifies parent component that the form was submitted.
     */
    formSubmittedStatus: EventEmitter<SubmitFormEventResult>;
    /**
     * @description Represents the form instance. @see NgForm
     */
    ngForm: NgForm;
    /** Inner form group directive. */
    formGroup: FormGroupDirective;
    /** Inner form fields */
    fields: QueryList<FormGeneratorFieldComponent>;
    /** @hidden */
    doCheck$: Subject<void>;
    /** @hidden */
    ngSubmit$: Subject<void>;
    /** Array of form field controls. */
    get formFields(): PlatformFormFieldControl[];
    /**
     * @description Dynamically generated form. @see FormGeneratorService
     */
    form: DynamicFormGroup;
    /**
     * @description List of the form controls.
     */
    formControlItems: DynamicFormGroupControl[];
    /**
     * Set of flags representing if particular form item should be visible to the user.
     */
    shouldShowFields: {
        [key: string]: boolean;
    };
    /**
     * Flag representing that form is loading
     */
    formLoading: boolean;
    /**
     * Stream of form loading state.
     */
    loading$: BehaviorSubject<boolean>;
    /**
     * Stream of last form submission status.
     */
    formSubmittedStatus$: Subject<SubmitFormEventResult>;
    /**
     * Stream of last form submission value.
     */
    formValue$: BehaviorSubject<DynamicFormValue>;
    /**
     * @hidden
     * To differentiate between first loading when skeletons be shown and subsequent loadings when busy indicator be shown
     */
    _firstLoadingDone: boolean;
    /**
     * @hidden
     */
    hintOptions: HintOptions;
    /** @hidden */
    _errorModels: {
        type: string;
        value: any;
    }[];
    /**
     * @hidden
     */
    private _formItems;
    /**
     * @hidden
     */
    private _formValueSubscription;
    /** @hidden */
    private _refresh$;
    /**
     * @hidden
     * An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)
     */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _defaultHintOptions;
    /** @hidden */
    private _ngSubmitSubscription;
    /** @hidden */
    private _mappedFormitems;
    /** @hidden */
    constructor(_fgService: FormGeneratorService, _cd: ChangeDetectorRef, _providedHintOptions: FieldHintOptions);
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * Refreshes form items visibility with 'when' condition.
     */
    refreshStepsVisibility(): Promise<void>;
    /**
     * @hidden
     */
    _onSubmit(): Promise<void>;
    /**
     * Adds new control to an existing form.
     * @param control Control configuration to add.
     * @param path Path of the control.
     */
    addControl(control: DynamicFormItem, path?: string[]): Promise<void>;
    /**
     * Removes the control with the given name by the given path.
     * @param name Name of the control.
     * @param path Path of the control.
     */
    removeControl(name: string, path: string[]): Promise<void>;
    /**
     *
     * @hidden
     */
    _trackFn(index: number, value: DynamicFormGroupControl): string;
    /** @hidden */
    _groupTrackFn(index: number, value: DynamicFormGroupControl): string;
    /**
     *
     * @description Programmatically submit form.
     * This method also calls validation for the form items.
     */
    submit(): void;
    /** @hidden */
    _isAdvancedError(error: any): error is DynamicFormItemValidationObject;
    /** @hidden */
    _errorsTrackBy(_: number, error: {
        type: string;
        value: any;
    }): string;
    /**
     * @hidden
     */
    private _generateForm;
    /** @hidden */
    private _getOrderedControls;
    /** @hidden */
    private _getErrors;
    /** @hidden */
    private _listenToSubmit;
    /** @hidden */
    private _onFormItemsChange;
    /** @hidden */
    private _applyRank;
    /** @hidden */
    private _addControlToFormItems;
    /** @hidden */
    private _removeControlFromItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormGeneratorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormGeneratorComponent, "fdp-form-generator", never, { "formName": { "alias": "formName"; "required": false; }; "formItems": { "alias": "formItems"; "required": false; }; "mainTitle": { "alias": "mainTitle"; "required": false; }; "hideMainTItle": { "alias": "hideMainTItle"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "columnLayout": { "alias": "columnLayout"; "required": false; }; "labelColumnLayout": { "alias": "labelColumnLayout"; "required": false; }; "fieldColumnLayout": { "alias": "fieldColumnLayout"; "required": false; }; "gapColumnLayout": { "alias": "gapColumnLayout"; "required": false; }; "unifiedLayout": { "alias": "unifiedLayout"; "required": false; }; "inlineColumnLayout": { "alias": "inlineColumnLayout"; "required": false; }; "noAdditionalContent": { "alias": "noAdditionalContent"; "required": false; }; }, { "formCreated": "formCreated"; "formSubmitted": "formSubmitted"; "formSubmittedStatus": "formSubmittedStatus"; }, never, ["*"], true, never>;
}

declare class GetOrderedFieldControlsPipe implements PipeTransform {
    /** @hidden */
    transform(field: DynamicFormGroupControl): DynamicFormControl[];
    static ɵfac: i0.ɵɵFactoryDeclaration<GetOrderedFieldControlsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetOrderedFieldControlsPipe, "getOrderedFieldControls", true>;
}

declare class DynamicFormGeneratorObjectStatusComponent extends BaseDynamicFormGeneratorControl<ObjectStatusDynamicFormFieldItem> {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGeneratorObjectStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGeneratorObjectStatusComponent, "fdp-dynamic-form-generator-object-status", never, {}, {}, never, never, true, never>;
}

declare class GetHintOptionsPipe implements PipeTransform {
    /** @hidden */
    private readonly _defaultHintOptions;
    /** @hidden */
    constructor(_providedHintOptions: FieldHintOptions);
    /**
     * Used for extracting hintOptions from GuiOptions. This will coerce string | HintOptions to FieldHintOptions,
     * will combine default value of hints for form generator with provided options.
     */
    transform(hintOptions: BaseDynamicFormItemGuiOptions | DynamicFormItemGuiOptions | undefined): FieldHintOptions | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetHintOptionsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GetHintOptionsPipe, "getHintOptions", true>;
}

/**
 * Adds Form Generator functionality to your application.
 *
 * Can be imported in two ways:
 * * Plain PlatformFormGeneratorModule with default configuration
 * * With `withConfig()` method which allows passing custom default configuration.
 */
/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformFormGeneratorModule {
    /**
     * Allows configuring module on a global level with custom configuration.
     * @param config User's custom configuration.
     */
    static withConfig(config: Partial<FormGeneratorModuleConfig>): ModuleWithProviders<PlatformFormGeneratorModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformFormGeneratorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformFormGeneratorModule, never, [typeof FormGeneratorComponent, typeof DynamicFormControlFieldDirective, typeof DynamicFormControlDirective, typeof DynamicFormGeneratorCheckboxComponent, typeof DynamicFormGeneratorInputComponent, typeof DynamicFormGeneratorEditorComponent, typeof DynamicFormGeneratorSelectComponent, typeof DynamicFormGeneratorRadioComponent, typeof DynamicFormGeneratorDatepickerComponent, typeof DynamicFormGeneratorSwitchComponent, typeof FormGeneratorFieldComponent, typeof DynamicFormGeneratorMultiInputComponent, typeof GetOrderedFieldControlsPipe, typeof DynamicFormGeneratorObjectStatusComponent, typeof GetHintOptionsPipe], [typeof FormGeneratorComponent, typeof DynamicFormControlFieldDirective, typeof DynamicFormControlDirective, typeof DynamicFormGeneratorCheckboxComponent, typeof DynamicFormGeneratorInputComponent, typeof DynamicFormGeneratorEditorComponent, typeof DynamicFormGeneratorSelectComponent, typeof DynamicFormGeneratorRadioComponent, typeof DynamicFormGeneratorDatepickerComponent, typeof DynamicFormGeneratorSwitchComponent, typeof FormGeneratorFieldComponent, typeof i16.ContentDensityModule, typeof DynamicFormGeneratorObjectStatusComponent, typeof GetHintOptionsPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformFormGeneratorModule>;
}

declare const FDP_FORM_GENERATOR_DEFAULT_HINT_OPTIONS: InjectionToken<Omit<FieldHintOptions, "content">>;

declare const dynamicFormFieldProvider: StaticProvider;
declare const dynamicFormGroupChildProvider: StaticProvider;
declare const FORM_GENERATOR_ITEM_CONFIG: InjectionToken<DynamicFormFieldItem>;
declare const FORM_GENERATOR_CONFIG: InjectionToken<FormGeneratorConfig>;
declare const defaultFormGeneratorConfig: FormGeneratorConfig;
declare const defaultFormGeneratorConfigProvider: Provider;
declare const defaultFormGeneratorItemConfig: Partial<DynamicFormFieldItem>;
declare const defaultFormGeneratorItemConfigProvider: Provider;

declare const defaultFormFieldHintOptions: Omit<FieldHintOptions, 'content'>;

declare const FORM_GROUP_CHILD_FIELD_TOKEN: InjectionToken<string>;
declare const DefaultHorizontalLabelLayout: ColumnLayout;
declare const DefaultVerticalLabelLayout: ColumnLayout;
declare const DefaultHorizontalFieldLayout: ColumnLayout;
declare const DefaultVerticalFieldLayout: ColumnLayout;
declare const DefaultGapLayout: ColumnLayout;

/**
 * @license
 * F. Kolar
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *
 */

declare const formGroupProvider: Provider;
type FormGroupField = (FormField | FormFieldGroup) & {
    hintOptions?: HintOptions;
};
/**
 *
 * FormGroup represent high order container aggregating FormFields and ability to distribute these
 * fields into columns. It mainly hides implementation details that we need to deal with every
 * time we are building a form. We have input fields , error managements, different states,
 * hints and many more.
 *
 * Well behaved form that has information side by side in multiple
 * columns needs to also know how to merge properly.
 *
 * Just to get the idea about the structure without actual input components inside
 *
 * ```html
 * <fdp-form-group [hintPlacement]="'inline'" columnLayout="XL2-L2-M1-S1">
 *    <fdp-form-field [id]="'Field A'" [rank]="10" column="1">
 *    </fdp-form-field>
 *
 *    <fdp-form-field [id]="'Field B'" [rank]="30" column="1">
 *    </fdp-form-field>
 *
 *    <fdp-form-field [id]="'Field C'"  [rank]="20" column="1">
 *    </fdp-form-field>
 *
 *    <fdp-form-field [id]="Field D"  [rank]="20" column="2">
 *    </fdp-form-field>
 *
 *
 *    <fdp-form-field [id]="'Field E'" [rank]="30" column="2">
 *    </fdp-form-field>
 * </fdp-form-group>

 *
 * ````
 *
 *
 * Which can be translated like this
 * [Field A] - First column, rank 10
 * [Field B] - First column, rank 30
 * [Field C] - First column, rank 20
 * [Field D] - Second column, rank 20
 * [Field E] - Second column, rank 30
 *
 * What we expect that it creates following form with two column layout:
 * [Field A]      [Field D]
 * [Field C]      [Field E]
 * [Field B]
 *
 * You can see all is sorted accordingly by rank (C goes before B).
 *
 * When you move into smaller device and all is merged into one columns the naive solution would be:
 *
 * [Field A]
 * [Field C]
 * [Field B]
 * [Field D]
 * [Field E]
 *
 * The fields needs to restructure according to their original positioning. When Field D was on the
 * top why we should move it to the bottom? The more correct solution should be following.
 *
 * [Field A]
 * [Field D]
 * [Field C]
 * [Field E]
 * [Field B]
 *
 * Fields nicely merge together. they don't wrap.
 *
 *
 * Besides this layout support it also wraps form functionality and it can work with FormGroup.
 * You can also decide if you want your form with <form> element or without it.
 *
 *
 */
declare class FormGroupComponent implements FormGroupContainer, OnInit, AfterContentInit, AfterViewInit, OnDestroy, OnChanges {
    /** Id for the form group element */
    id: string;
    /** Name property to be set on a form. Will be used if `useForm` is set to true */
    name: string;
    /** Indicates if group is editable */
    editable: boolean;
    /** Indicates when labels should not be displayed */
    noLabelLayout: boolean;
    /** User's custom classes */
    class: string;
    /**
     * Form group hint options
     */
    hint: HintInput;
    /**
     * Defines column layout for inline items.
     */
    set inlineColumnLayout(value: ColumnLayout);
    get inlineColumnLayout(): ColumnLayout;
    /**
     * Defines label's column layout.
     */
    labelColumnLayout: ColumnLayout;
    /**
     * Defines field's column layout.
     */
    fieldColumnLayout: ColumnLayout;
    /**
     * Defines gap column layout.
     */
    gapColumnLayout: ColumnLayout;
    /** Angular FormGroup where all underlying controls will be attached to. */
    formGroup: FormGroup;
    /** This is rather simple for now just to have some Section Title if needed */
    topTitle: string;
    /** Form's main title. */
    mainTitle: Nullable<string>;
    /** Whether to hide form's main title. Default is false. */
    hideMainTItle: boolean;
    /**
     * Convenient way to initialize internal FormControls from object
     */
    object: any;
    /**
     * Translations template reference.
     *
     * This is just here to support several ways to pass translation.
     *
     * One way is to provide ng-template #i18n inside the form-group tag and the other one
     * some global one as binding
     */
    i18Strings: TemplateRef<any>;
    /** Whether to wrap all the provided content in a `<form>` */
    useForm: boolean;
    /**
     * Specify the column layout in the format `XLn-Ln-Mn-Sn` where n is the number of columns and can be different for each size.
     * eg: XL2-L2-M2-S1 would create 2-column layouts for XL, L, and M sizes and single-column layout for S size.
     */
    columnLayout: Nullable<string>;
    /** Whether all form items should have identical layout provided for form group */
    unifiedLayout: boolean;
    /**
     * onSubmit event
     */
    onSubmit: EventEmitter<any>;
    /**
     * Native form element. Available with `[useForm]="true"` input property.
     */
    nativeForm: NgForm;
    /** @hidden */
    i18Template: TemplateRef<any>;
    /**
     * @hidden
     *
     * Keep track of added form fields children in correct order.
     *
     * Since "descendants: true" includes fields of nested form group as well.
     *
     * We are forced to use "ContentChildren" so FormField children can be used
     * with optional rendering (ngIf) safely.
     *
     * Form fields within the formGroup is driven by multi-zone layout support. We need to be
     * able to add number of FormFields, and based on given configuration (zone, rank) render them
     * under correct zone  (top, bottom, left, right).
     *
     * We want to make sure that we don't include content and then try to somehow position it as it
     * would lead to the UI where user can see elementing moving as you try to position it.
     *
     */
    protected formGroupChildren: QueryList<FormGroupField>;
    /** @hidden */
    private _errorDirectives;
    /** @hidden */
    xlColumnsNumber: number;
    /** @hidden */
    lgColumnsNumber: number;
    /** @hidden */
    mdColumnsNumber: number;
    /**
     * @hidden
     * User responsive layout
     */
    xlCol: string;
    /**
     * @hidden
     * Packed fields which should be rendered
     */
    formRows: {
        [key: number]: FieldColumn | FieldGroup;
    };
    /** @hidden */
    _hintOptions: Nullable<HintOptions>;
    /** @hidden */
    readonly contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    _inlineColumnLayoutClass: string;
    /** @hidden */
    protected _destroyRef: DestroyRef;
    /** @hidden */
    private _inlineColumnLayout;
    /**
     * @hidden
     *
     * List of direct FdpFormGroup's children.
     *
     * Since "formGroupChildren" uses "{ descendants: true }" option that means
     * "formGroupChildren" will keep track of nested FdpFormGroup fields as well.
     * This list relies on the injection mechanism so nested FdpFormGroup's fields/fieldGroups
     * will be omitted
     */
    private _formGroupDirectChildren;
    /** @hidden */
    private readonly _subscriptions;
    /** @hidden */
    private readonly _cd;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _formContainer;
    /** @hidden */
    private readonly _defaultHintOptions;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    addFormField(formField: PlatformFormField): void;
    /** @hidden */
    removeFormField(formField: PlatformFormField): void;
    /** @hidden */
    addFormFieldGroup(formFieldGroup: FormFieldGroup): void;
    /** @hidden */
    removeFormFieldGroup(formFieldGroup: FormFieldGroup): void;
    /** @hidden */
    addFormControl(name: string, control: AbstractControl): void;
    /** @hidden */
    removeFormControl(name: string): void;
    /** @hidden */
    trackByFn(index: number): number;
    /** @hidden */
    trackByFieldName(index: number, field: Field): string | undefined;
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden used for template side Type correction */
    $fieldGroup: (f: any) => FieldGroup;
    /** @hidden */
    private _listenToFormGroupChildren;
    /** @hidden */
    private _listenFormFieldColumnChange;
    /**
     * @hidden
     * Assign a fields or field group to specified columns with rank.
     * if `columnLayoutType` is given a fields without column property will set on last column.
     * Otherwise the fields set 1 column.
     */
    private _updateFieldByColumn;
    /** @hidden Validate column number */
    private _validateFieldColumn;
    /** @hidden */
    private _updateFormFieldsProperties;
    /**
     * @hidden
     * Pass some global properties to each field. Even formGroup cna be inject directly inside form
     * field we are using here a setter method to initialize the
     *
     */
    private _updateFormFieldProperties;
    /**
     * @hidden
     * if `columnLayoutType` is given, set those column layouts appropriately. Otherwise, a layout will set on 1 column
     */
    private _setUserLayout;
    /** @hidden */
    private _getColumnNumbers;
    /** @hidden */
    private _addDirectFormGroupChild;
    /** @hidden */
    private _removeDirectFormGroupChild;
    /**
     * @hidden
     * Get direct form group children in the original order
     */
    private _getFormGroupChildren;
    /** @hidden */
    private _updateInlineColumnLayout;
    /**
     * @hidden
     * have to trigger change detection here in order to re-check contents
     * inside "FormField.renderer" template every time component's dimensions changed
     */
    private _trackFormGroupResize;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormGroupComponent, "fdp-form-group", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "noLabelLayout": { "alias": "noLabelLayout"; "required": false; }; "class": { "alias": "class"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "inlineColumnLayout": { "alias": "inlineColumnLayout"; "required": false; }; "labelColumnLayout": { "alias": "labelColumnLayout"; "required": false; }; "fieldColumnLayout": { "alias": "fieldColumnLayout"; "required": false; }; "gapColumnLayout": { "alias": "gapColumnLayout"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "topTitle": { "alias": "topTitle"; "required": false; }; "mainTitle": { "alias": "mainTitle"; "required": false; }; "hideMainTItle": { "alias": "hideMainTItle"; "required": false; }; "object": { "alias": "object"; "required": false; }; "i18Strings": { "alias": "i18Strings"; "required": false; }; "useForm": { "alias": "useForm"; "required": false; }; "columnLayout": { "alias": "columnLayout"; "required": false; }; "unifiedLayout": { "alias": "unifiedLayout"; "required": false; }; }, { "onSubmit": "onSubmit"; }, ["i18Template", "formGroupChildren", "_errorDirectives"], ["fdp-form-group"], true, never>;
    static ngAcceptInputType_useForm: unknown;
}

declare const FDP_FORM_FIELD_HINT_OPTIONS_DEFAULT: InjectionToken<Omit<FieldHintOptions, "content">>;
interface HintLayoutConfig {
    hintOnInputBreakpoints: Array<keyof ColumnLayout>;
    hintPlaceMinSize: Column;
}
declare const FDP_FORM_FIELD_HINT_LAYOUT_CONFIG: InjectionToken<HintLayoutConfig>;

type Layouts = {
    labelColumnLayout: ColumnLayout;
    fieldColumnLayout: ColumnLayout;
    gapColumnLayout: ColumnLayout;
};
/**
 * Should be used in component level. Ideally placed on container component,
 * so that every it's child FormField can have shared information about peers'
 * need about inline help place.
 */
declare class FormFieldLayoutService {
    private _hintLayoutConfig;
    /**
     * Will notify if inline help place is needed. If any of the FormFields in group have
     * hintOptions config set the way that it might end up on 'input', then it will emit true
     */
    readonly needsInlineHelpPlace: Observable<boolean>;
    /** @hidden */
    private _needsInlineHelpPlace$;
    /** @hidden */
    private _elementsMap;
    /** @hidden */
    constructor(_hintLayoutConfig: HintLayoutConfig);
    /**
     * Notify service about target component's requirement for the place for inline help
     */
    setNeedsInlineHelp(target: Record<string, any>, isNeeded: boolean): void;
    /**
     * Function will give place for hint in case it does not have it yet,
     * if combined needsInlineHelpPlace value is true
     */
    getFixedLayouts(layouts: Layouts): Layouts;
    /**
     * Remove component from the combined value calculations
     */
    removeEntry(target: Record<string, any>): void;
    /**
     * Will loop through all registered components and if any of them has need for
     * inline help place, then it will notify listeners about it and also will set
     * local variable
     * @hidden
     */
    private _updateCombinedValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldLayoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormFieldLayoutService>;
}

/**
 * Form Field represent actual row and aggregates common behavior for the input field such as
 * error, label or hint.
 * Hint is also responsible for listening for FieldControl changes and trigger necessary
 * change detection
 *
 */
declare class FormFieldComponent implements PlatformFormField, AfterContentInit, AfterViewInit, OnDestroy, OnInit, OnChanges {
    private _cd;
    readonly formFieldGroup: FormFieldGroup;
    readonly _defaultResponsiveBreakPointConfig: ResponsiveBreakPointConfig;
    readonly _responsiveBreakpointsService: ResponsiveBreakpointsService;
    private _hintLayoutConfig;
    /** Form field label */
    label: string;
    /**
     * Suffix for ids of control elements inside this form field
     */
    id: string;
    /** Hint to be placed next to label */
    hint: Nullable<FieldHintInput>;
    /**
     * Indicates when form field label should not be displayed
     */
    noLabelLayout: boolean;
    /**
     * The list of validators applied to the form field.
     */
    validators: Array<ValidatorFn>;
    /**
     * Rank is used for ordering.
     * First lower number, then - higher
     */
    rank: number;
    /**
     * Placeholder for the field
     */
    placeholder: string;
    /** Form Container column it belongs to */
    column: number;
    /** object for placing field in column in each screen layout */
    set columnLayout(layout: ColumnLayout | undefined);
    get columnLayout(): ColumnLayout;
    /**
     * Defines label's column layout.
     */
    set labelColumnLayout(value: ColumnLayout | undefined);
    get labelColumnLayout(): ColumnLayout;
    /**
     * Defines field's column layout.
     */
    set fieldColumnLayout(value: ColumnLayout | undefined);
    get fieldColumnLayout(): ColumnLayout;
    /**
     * Defines gap column layout.
     */
    set gapColumnLayout(value: ColumnLayout | undefined);
    get gapColumnLayout(): ColumnLayout;
    /**
     * Translations template reference.
     * This is in most of the cases set from parent container (form-group)
     */
    i18Strings: TemplateRef<any>;
    /** Set when form field is a mandatory one. */
    required: boolean;
    /**
     * Indicates if field is editable
     */
    set editable(value: boolean);
    get editable(): boolean;
    /**
     * Form field custom width in columns must be between 1 - 12
     */
    columns: Column;
    /**
     * marks field as disabled. used in reactive form approach.
     */
    disabled: boolean;
    /** Whether label text should be appended with colon. */
    colon: boolean;
    /**
     * Form Group Container to bind the Form-Field to.
     * This will override default value injected by constructor
     */
    formGroupContainer: FormGroupContainer;
    /** Emits whenever formFieldControl's state changes */
    onChange: EventEmitter<string>;
    /** Emits whenever column layout is changed */
    onColumnChange: EventEmitter<boolean>;
    /**
     * @hidden
     * Form field template reference
     */
    renderer: TemplateRef<any>;
    /** @hidden */
    formFieldExtras?: ElementRef<HTMLElement>;
    /** @hidden */
    labelCol?: ElementRef<HTMLDivElement>;
    /** @hidden */
    inputMessageGroup: ElementRef<HTMLElement>;
    /** @hidden */
    innerErrorRenderers: TemplateRef<any>;
    /** @hidden */
    private _errorDirectiveQuery;
    /** @hidden */
    private readonly _inputMessageGroupCmp;
    /** Combined Error directives from field itself and parent form container. */
    get errorDirectives(): FormError[];
    /** @hidden */
    isHorizontal$: Signal<boolean | undefined>;
    /**
     * Child FormFieldControl
     */
    control: PlatformFormFieldControl | null;
    /** @hidden */
    _labelColumnLayoutClass: string;
    /** @hidden */
    _fieldColumnLayoutClass: string;
    /** @hidden */
    _gapColumnLayoutClass: string;
    /**
     * hint and hint placement coerced to the FieldHintOptions
     */
    hintOptions: FieldHintOptions;
    /** @hidden */
    _errorDirectives: FormError[];
    /** Grouped errors. */
    groupedErrors: FormFieldErrorDirectiveContext[];
    /** Event emited when errors object being changed. */
    errorsChange$: Subject<void>;
    /**
     * @hidden
     * Optional FormControl
     */
    formControl: FormControl;
    /** @hidden */
    get _groupHost(): FormGroupContainer | FormFieldGroup;
    /**
     * Will be updated during onChanges and resize, resulting correct placement of the
     * hint respecting passed configs and given breakpoint of screen.
     */
    hintTarget?: string;
    /** @hidden */
    protected _editable: boolean;
    /** @hidden */
    private _isColumnLayoutEnabled;
    /** @hidden column number for different screen sizes */
    private _xlColumnNumber;
    /** @hidden */
    private _lgColumnNumber;
    /** @hidden */
    private _mdColumnNumber;
    /** @hidden */
    private _sColumnNumber;
    /** @hidden */
    private _columnLayout;
    /** @hidden */
    private readonly _responsiveBreakPointConfig;
    /** @hidden */
    private _labelColumnLayout;
    /** @hidden */
    private _fieldColumnLayout;
    /** @hidden */
    private _gapColumnLayout;
    /** @hidden */
    private _formGroupErrorDirectives;
    /** @hidden */
    private _formGroupErrorDirectivesSubscription;
    /** @hidden */
    private _errorDirectivesCdr;
    /** @hidden whether label and control are vertically aligned */
    private get _isHorizontalAlignment();
    /**
     * @hidden
     * Sum of extra heights inside form control and formFieldExtras.
     * Label will be shifted by this number in order to be properly aligned with the control
     */
    get _controlExtrasHeightPx(): number | null;
    /** @hidden */
    private _labelColumnLayout$;
    /** @hidden */
    private _fieldColumnLayout$;
    /** @hidden */
    private _gapColumnLayout$;
    /** @hidden */
    private _needsInlineHelpPlaceSubscription?;
    /** @hidden */
    private _breakPointObserver;
    /** @hidden */
    private _formFieldLayoutService;
    /** @hidden */
    private readonly _defaultHintOptions;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_cd: ChangeDetectorRef, formGroupContainer: FormGroupContainer, formFieldGroup: FormFieldGroup, _defaultResponsiveBreakPointConfig: ResponsiveBreakPointConfig, _responsiveBreakpointsService: ResponsiveBreakpointsService, _providedHintOptions: FieldHintOptions, _hintLayoutConfig: HintLayoutConfig, _selfFormFieldLayoutService: FormFieldLayoutService, _parentFormFieldLayoutService: FormFieldLayoutService);
    /**
     * Sets initial values for label, field and gap columns
     */
    setDefaultColumnLayout(): void;
    /** @hidden */
    listenToInlineHelpPlaceRequirementChanges(getSource: () => any): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    hasErrors(): boolean;
    /**
     * Register underlying form control
     * @param formFieldControl
     */
    registerFormFieldControl(formFieldControl: FormFieldControl): void;
    /**
     * Unregister underlying form control
     * @param formFieldControl
     */
    unregisterFormFieldControl(formFieldControl: FormFieldControl): void;
    /**
     * Groups
     */
    groupErrors(): void;
    /**
     * Gets prioritized control state based on the error types it has.
     */
    getPriorityState(): FormStates;
    /**
     * Sets error directives.
     */
    setErrorDirectives(directives: QueryList<FormError>): void;
    /**
     * Returns whether content of the provided hint is a string.
     * @hidden
     */
    isStringHint(hintOptions: HintContent): hintOptions is string;
    /** @hidden */
    _getLabelledBy(): string;
    /**
     * @hidden
     * Listens to form message component changes and passes its instance to the form control component.
     */
    private _listenToFormMessage;
    /** @hidden */
    private _validateErrorHandler;
    /** @hidden */
    private _hasValidators;
    /**
     * @hidden
     * Add FormField to FormGroup
     */
    private _addToFormGroup;
    /**
     * @hidden
     * Remove FormField from FormGroup
     */
    private _removeFromFormGroup;
    /**
     * @hidden
     * Add FormControl from FormGroup
     */
    private _addControlToFormGroup;
    /**
     * @hidden
     * Remove FormControl from FormGroup
     */
    private _removeControlFromFormGroup;
    /**
     * @hidden
     * Need to be able to set these properties on every level.
     *  - Global FormGroup Level as well each field
     *
     *  Todo: use more elegant way to set these properties.
     */
    private _updateControlProperties;
    /** @hidden */
    private _setLayout;
    /** @hidden */
    private _updateLayout;
    /** @hidden */
    private _updateHintOptions;
    /** @hidden */
    private _assignErrorDirectives;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null, { self: true; }, { optional: true; skipSelf: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "fdp-form-field", never, { "label": { "alias": "label"; "required": false; }; "id": { "alias": "id"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "noLabelLayout": { "alias": "noLabelLayout"; "required": false; }; "validators": { "alias": "validators"; "required": false; }; "rank": { "alias": "rank"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "column": { "alias": "column"; "required": false; }; "columnLayout": { "alias": "columnLayout"; "required": false; }; "labelColumnLayout": { "alias": "labelColumnLayout"; "required": false; }; "fieldColumnLayout": { "alias": "fieldColumnLayout"; "required": false; }; "gapColumnLayout": { "alias": "gapColumnLayout"; "required": false; }; "i18Strings": { "alias": "i18Strings"; "required": false; }; "required": { "alias": "required"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "colon": { "alias": "colon"; "required": false; }; "formGroupContainer": { "alias": "formGroupContainer"; "required": false; }; }, { "onChange": "onChange"; "onColumnChange": "onColumnChange"; }, ["formFieldExtras", "_errorDirectiveQuery"], ["*"], true, never>;
    static ngAcceptInputType_rank: string | number;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_editable: unknown;
    static ngAcceptInputType_columns: i1.Column | `${i1.Column}`;
}

/**
 * This extends core implementation  to support richer extensibility and instead of relying
 * only on ng-content selector this will allow you to put any content as trigger.
 *
 * Let's think of u
 */
declare class InputMessageGroupWithTemplate extends FormInputMessageGroupComponent {
    /**
     * To allow user to determine what event he wants to trigger the messages to show
     * Accepts any [HTML DOM Events](https://www.w3schools.com/jsref/dom_obj_event.asp).
     */
    triggers: (string | TriggerConfig)[];
    /**
     * Custom trigger element.
     */
    triggerItemTemplate: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputMessageGroupWithTemplate, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputMessageGroupWithTemplate, "fdp-input-message-group", never, { "triggers": { "alias": "triggers"; "required": false; }; }, {}, ["triggerItemTemplate"], ["*"], true, never>;
}

declare class FormFieldControlExtrasComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldControlExtrasComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldControlExtrasComponent, "fdp-form-field-extras", never, {}, {}, never, ["*"], true, never>;
}

declare class FormGroupHeaderComponent {
    /** Whether the header should wrap on multiple lines */
    readonly allowWrap: i0.InputSignalWithTransform<boolean, unknown>;
    /** Fields Group */
    fieldGroup: i0.InputSignal<FieldGroup | null | undefined>;
    /** Hint options */
    protected readonly hintOptions: i0.Signal<i1.HintOptions | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormGroupHeaderComponent, "[fdp-form-group-header]", never, { "allowWrap": { "alias": "allowWrap"; "required": false; "isSignal": true; }; "fieldGroup": { "alias": "fieldGroup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FieldGroupRowValuePipe implements PipeTransform {
    /** @hidden */
    transform(row: KeyValue<any, FieldColumn | FieldGroup>): FieldColumn;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldGroupRowValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FieldGroupRowValuePipe, "fieldGroupRowValue", true>;
}

declare class FormFieldErrorDirective<T = any> implements FormError<T>, OnInit {
    templateRef: TemplateRef<FormFieldErrorContext<T>>;
    private _viewContainer;
    private _cdr;
    /** Used to connect data with model for typings support. */
    fdpFormFieldErrorAs: T;
    /** Error name */
    error: string;
    /** Error type */
    fdpFormFieldErrorType: FormStates;
    /** @hidden */
    detectChanges$: Subject<void>;
    /** Error type. Defines which type to return. Either self, or from heading directive. */
    get type(): FormStates;
    /** @hidden */
    private _headingDirective;
    /** @hidden */
    private _descriptionDirective;
    /** @hidden */
    private _detectTimeout;
    /** @hidden */
    get _headingTemplateRef(): TemplateRef<FormFieldErrorContext<T>>;
    /** @hidden */
    get _descriptionTemplateRef(): TemplateRef<FormFieldErrorContext<T>> | null;
    /** @hidden */
    constructor(templateRef: TemplateRef<FormFieldErrorContext<T>>, _viewContainer: ViewContainerRef, _cdr: ChangeDetectorRef);
    /** @hidden */
    static ngTemplateContextGuard(dir: FormFieldErrorDirective, ctx: FormFieldErrorContext<any>): ctx is FormFieldErrorContext<any>;
    /** @hidden */
    ngOnInit(): void;
    /** Registers child heading directive. */
    registerHeading(directive: FormErrorHeading): void;
    /** Registers child description directive. */
    registerDescription(directive: FormErrorDescription): void;
    /** @hidden */
    private _createView;
    /** @hidden */
    private _detectChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldErrorDirective<any>, "[fdpFormFieldError]", never, { "fdpFormFieldErrorAs": { "alias": "fdpFormFieldErrorAs"; "required": false; }; "error": { "alias": "fdpFormFieldError"; "required": false; }; "fdpFormFieldErrorType": { "alias": "fdpFormFieldErrorType"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormFieldErrorHeadingDirective<T = any> implements FormErrorHeading {
    templateRef: TemplateRef<FormFieldErrorContext<T>>;
    private _formFieldErrorDirective;
    /** Used to connect data with model for typings support. */
    fdpFormFieldErrorHeadingAs: T;
    /** Error type. */
    fdpFormFieldErrorHeadingType: FormStates | undefined;
    /** @hidden */
    constructor(templateRef: TemplateRef<FormFieldErrorContext<T>>, _formFieldErrorDirective: FormError);
    /** @hidden */
    static ngTemplateContextGuard(dir: FormFieldErrorHeadingDirective, ctx: FormFieldErrorContext<any>): ctx is FormFieldErrorContext<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorHeadingDirective<any>, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldErrorHeadingDirective<any>, "[fdpFormFieldErrorHeading]", never, { "fdpFormFieldErrorHeadingAs": { "alias": "fdpFormFieldErrorHeadingAs"; "required": false; }; "fdpFormFieldErrorHeadingType": { "alias": "fdpFormFieldErrorHeadingType"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormFieldErrorDescriptionDirective<T = any> implements FormErrorDescription {
    templateRef: TemplateRef<FormFieldErrorContext<T>>;
    private _formFieldErrorDirective;
    /** Used to connect data with model for typings support. */
    fdpFormFieldErrorDescriptionAs: T;
    /** @hidden */
    constructor(templateRef: TemplateRef<FormFieldErrorContext<T>>, _formFieldErrorDirective: FormError);
    /** @hidden */
    static ngTemplateContextGuard(dir: FormFieldErrorDescriptionDirective, ctx: FormFieldErrorContext<any>): ctx is FormFieldErrorContext<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldErrorDescriptionDirective<any>, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormFieldErrorDescriptionDirective<any>, "[fdpFormFieldErrorDescription]", never, { "fdpFormFieldErrorDescriptionAs": { "alias": "fdpFormFieldErrorDescriptionAs"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class FdpFormGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FdpFormGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FdpFormGroupModule, never, [typeof FormGroupComponent, typeof FormFieldComponent, typeof InputMessageGroupWithTemplate, typeof FormFieldGroupComponent, typeof FormFieldControlExtrasComponent, typeof FormGroupHeaderComponent, typeof FieldGroupRowValuePipe, typeof FormFieldErrorDirective, typeof FormFieldErrorHeadingDirective, typeof FormFieldErrorDescriptionDirective], [typeof FormGroupComponent, typeof FormFieldComponent, typeof InputMessageGroupWithTemplate, typeof FormFieldGroupComponent, typeof FormFieldControlExtrasComponent, typeof FormGroupHeaderComponent, typeof FieldGroupRowValuePipe, typeof FormFieldErrorDirective, typeof FormFieldErrorHeadingDirective, typeof FormFieldErrorDescriptionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FdpFormGroupModule>;
}

declare const FDP_FORM_ERROR_DIRECTIVE: InjectionToken<unknown>;

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformInputModule, never, [typeof InputComponent], [typeof InputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformInputModule>;
}

/**
 * Fundamental input group addon body component
 */
declare class InputGroupAddonBodyComponent implements OnInit {
    private _elementRef;
    private _renderer;
    /**
     * indicates if addon contains a button
     */
    set hasButton(hasButton: boolean);
    /** @hidden */
    constructor(_elementRef: ElementRef<HTMLElement>, _renderer: Renderer2, contentDensityObserver: ContentDensityObserver);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    private _addClassNameToHostElement;
    /** @hidden */
    private _removeClassNameFromHostElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroupAddonBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputGroupAddonBodyComponent, "fdp-input-group-addon-body", never, { "hasButton": { "alias": "hasButton"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare const inputGroupAddonChildProvider: Provider;
/**
 * Fundamental input group addon component
 *
 * This component is intended to be used inside `<fdp-input-group>`
 *
 *
 * Input group addon can contain a plain text:
 * ```
 * <fdp-input-group-addon>$</fdp-input-group-addon>
 * ```
 * Icon:
 * ```
 * <fdp-input-group-addon><i class="sap-icon--employee"></i></fdp-input-group-addon>
 * ```
 * Button component:
 * ```
 * <fdp-input-group-addon><fdp-button label="Action"></fdp-button></fdp-input-group-addon>
 * ```
 *
 */
declare class InputGroupAddonComponent implements AfterContentInit {
    private _renderer;
    /** @hidden */
    set disabled(disabled: boolean);
    get disabled(): boolean;
    /** @hidden */
    contentTemplateRef: TemplateRef<any>;
    /** @hidden */
    platformButton: Nullable<ButtonModel>;
    /** @hidden */
    coreButton: Nullable<BaseButton>;
    /** @hidden */
    set buttonElementRef(buttonComponentElementRef: ElementRef<HTMLElement>);
    /** @hidden */
    get button(): Nullable<ButtonModel>;
    /** @hidden */
    private _disabled;
    /** @hidden */
    constructor(_renderer: Renderer2);
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    private _setButtonControlOptions;
    /** @hidden */
    private _setButtonElementClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroupAddonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputGroupAddonComponent, "fdp-input-group-addon", never, {}, {}, ["platformButton", "coreButton", "buttonElementRef"], ["*"], true, never>;
}

declare const CSS_CLASS_NAME: {
    readonly host: "fdp-input-group";
    readonly input: "fd-input-group__input";
    readonly addon: "fd-input-group__addon";
    readonly addonButton: "fd-input-group__addon--button";
    readonly button: "fd-input-group__button";
};
declare const INPUT_GROUP_CHILD_TOKEN: InjectionToken<string>;

/**
 * Default options for platform input group
 */
declare class InputGroupConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /** @hidden */
    constructor(platformConfig: PlatformConfig);
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<InputGroupConfig>): (platformConfig: PlatformConfig) => InputGroupConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroupConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InputGroupConfig>;
}

/**
 * fdp-input-group needs it's own input component to
 * register INPUT_GROUP_CHILD in order to render
 * input group content children in the order that they are placed
 *
 */
declare const inputGroupInputChildProvider: Provider;
/**
 * Fundamental input group input component
 *
 * This component is intended to be used inside `<fdp-input-group>`
 *
 * Example:
 * ```
 * <fdp-input-group name="group">
 *   <fdp-input-group-input type="email"></fdp-input-group-input>
 * </fdp-input-group>
 * ```
 *
 */
declare class InputGroupInputComponent {
    /** InputType 'text' | 'number' | 'email' | 'password' */
    type: InputType;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroupInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputGroupInputComponent, "fdp-input-group-input", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Fundamental input group component
 *
 * ```html
 * <fdp-input-group>
 *   <fdp-input-group-addon>$</fdp-input-group-addon>
 *   <fdp-input-group-input type="number"></fdp-input-group-input>
 *   <fdp-input-group-addon>0.00</fdp-input-group-addon>
 * </fdp-input-group>
 * ```
 *
 */
declare class InputGroupComponent implements OnInit, AfterContentInit {
    readonly _cvaControl: CvaControl<string | number>;
    private _renderer;
    protected _hostElementRef: ElementRef<HTMLElement>;
    protected _inputGroupConfig: InputGroupConfig;
    /** Input value */
    set value(value: any);
    get value(): any;
    /** @hidden */
    _children: QueryList<InputGroupInputComponent | InputGroupAddonComponent>;
    /** @hidden */
    _input: InputGroupInputComponent;
    /** @hidden */
    set _inputComponentElement(inputComponentElementRef: ElementRef<HTMLElement>);
    /** @hidden */
    _beforeInputAddons: InputGroupAddonComponent[];
    /** @hidden */
    _afterInputAddons: InputGroupAddonComponent[];
    /** @hidden */
    constructor(_cvaControl: CvaControl<string | number>, _renderer: Renderer2, _hostElementRef: ElementRef<HTMLElement>, _inputGroupConfig: InputGroupConfig);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /**
     * @hidden
     * override base functionality to catch new disabled state
     */
    setDisabledState(disabled: boolean): void;
    /** @hidden */
    _onChangeInputValue(value: string): void;
    /** @hidden */
    _onKeyPress(event: KeyboardEvent): void;
    /** @hidden */
    private _listenToChildrenQueryListChanges;
    /** @hidden */
    private _setInputElementClass;
    /** @hidden */
    private _createAddonsGroups;
    /** @hidden */
    private _isInputChild;
    /** @hidden */
    private _isAddonChild;
    /** @hidden */
    private _setAddonsOptions;
    /** @hidden */
    private _addClassNameToHostElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputGroupComponent, "fdp-input-group", never, { "value": { "alias": "value"; "required": false; }; }, {}, ["_input", "_children"], never, true, [{ directive: typeof i1$1.CvaDirective; inputs: { "placeholder": "placeholder"; "disabled": "disabled"; "readonly": "readonly"; "state": "state"; "name": "name"; "stateMessage": "stateMessage"; }; outputs: {}; }]>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformInputGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformInputGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformInputGroupModule, never, [typeof InputGroupComponent, typeof InputGroupAddonComponent, typeof InputGroupAddonBodyComponent, typeof InputGroupInputComponent], [typeof InputGroupComponent, typeof InputGroupAddonComponent, typeof InputGroupInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformInputGroupModule>;
}

/**
 * Default options for Multi-Combobox
 */
declare class MultiComboboxConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /**
     * String matching strategy for typeahead list. Default: 'starts with per term'
     */
    matchingStrategy: MatchingStrategy;
    /**
     * Maps data providers
     */
    providers: Map<string, DataProvider<any>> | null;
    /** @hidden */
    constructor(platformConfig: PlatformConfig);
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<MultiComboboxConfig>): (platformConfig: PlatformConfig) => MultiComboboxConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiComboboxConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MultiComboboxConfig>;
}

declare const MAP_LIMIT: InjectionToken<number>;
type FdpMultiComboboxDataSource<T> = MultiComboBoxDataSource<T> | Observable<T[]> | T[];
declare class MultiComboboxSelectionChangeEvent {
    source: BaseMultiCombobox;
    selectedItems: SelectableOptionItem['value'];
    /**
     * Multi Combobox selection change event
     * @param source Multi Combobox component
     * @param selectedItems Selected items
     */
    constructor(source: BaseMultiCombobox, selectedItems: SelectableOptionItem['value']);
}
declare abstract class BaseMultiCombobox extends CollectionBaseInput implements OnChanges, AfterViewInit, OnDestroy {
    /**
     * @hidden
     * Method to set input text as item label.
     */
    abstract setInputTextFromOptionItem(item: SelectableOptionItem): void;
    /**
     * @hidden
     * Toggle item selection.
     */
    abstract toggleSelection(item: SelectableOptionItem): void;
    /**
     * @hidden
     * Toggle item selection by input text value.
     */
    abstract toggleSelectionByInputText(): void;
    /** Provides selected items. */
    selectedItems: any[];
    /** Provides maximum height for the optionPanel. */
    maxHeight: string;
    /**
     * Whether AddOn Button should be focusable
     * @default true
     */
    buttonFocusable: boolean;
    /** Datasource for suggestion list. */
    set dataSource(value: FdpMultiComboboxDataSource<any>);
    get dataSource(): FdpMultiComboboxDataSource<any>;
    /** Whether the autocomplete should be enabled; Enabled by default. */
    autoComplete: boolean;
    /**
     * TODO: Name of the entity for which DataProvider will be loaded. You can either pass list of
     * items or use this entityClass and internally we should be able to do lookup to some registry
     * and retrieve the best matching DataProvider that is set on application level
     */
    entityClass: string;
    /** Whether the multi-combobox should be built on mobile mode. */
    mobile: boolean;
    /** Multi Combobox Mobile Configuration, it's applied only, when mobile is enabled. */
    mobileConfig: MobileModeConfig;
    /** Tells the multi-combobox if we need to group items. */
    group: boolean;
    /** A field name to use to group data by (support dotted notation). */
    groupKey: string;
    /** The field to show data in secondary column. */
    secondaryKey: string;
    /** Show the second column (applicable for two columns layout). */
    showSecondaryText: boolean;
    /** Horizontally align text inside the second column (applicable for two columns layout). */
    secondaryTextAlignment: TextAlignment;
    /** Turns on/off Adjustable Width feature. */
    autoResize: boolean;
    /** Value of the multi combobox */
    set value(value: any);
    get value(): any;
    /**
     * Preset options for the Select body width, whatever is chosen, the body has a 600px limit.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control. - Default
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * 'fit-content' will apply width needed to properly display items inside, independent of control.
     */
    fillControlMode: PopoverFillMode;
    /** Sets title attribute to addon button. */
    addonIconTitle: string;
    /**
     * @deprecated Use the i18n module to modify the translation for this string.
     * Sets invalid entry message.
     * */
    invalidEntryMessage: Nullable<string>;
    /** Turns limitless mode, ON or OFF */
    limitless: boolean;
    /** Whether to open the dropdown when the addon button is clicked. */
    openDropdownOnAddOnClicked: boolean;
    /** Event emitted when item is selected. */
    selectionChange: EventEmitter<MultiComboboxSelectionChangeEvent>;
    /** @hidden Emits event when the menu is opened/closed. */
    isOpenChange: EventEmitter<boolean>;
    /** Event emitted when data loading is started. */
    onDataRequested: EventEmitter<void>;
    /** Event emitted when data loading is finished. */
    onDataReceived: EventEmitter<void>;
    /** Emits event when the addon button is clicked. */
    addOnButtonClicked: EventEmitter<Event>;
    /** @hidden */
    listComponent: ListComponent;
    /** @hidden */
    searchInputElement: ElementRef;
    /** @hidden */
    customTemplates: QueryList<TemplateDirective>;
    /**
     * @hidden
     * Custom Option item Template.
     */
    optionItemTemplate: TemplateRef<any>;
    /**
     * @hidden
     * Custom Group Header item Template.
     */
    groupItemTemplate: TemplateRef<any>;
    /**
     * @hidden
     * Custom Secondary item Template.
     */
    secondaryItemTemplate: TemplateRef<any>;
    /**
     * @hidden
     * Custom Selected option item Template.
     */
    selectedItemTemplate: TemplateRef<any>;
    /** @hidden */
    _contentDensity: ContentDensity;
    /** @hidden */
    listTemplate: TemplateRef<any>;
    /** Set the input text of the input. */
    set inputText(value: string);
    /** Get the input text of the input. */
    get inputText(): string;
    /** Is empty search field. */
    get isEmptyValue(): boolean;
    /** @hidden */
    get isGroup(): boolean;
    /** Whether the Multi Input is opened. */
    isOpen: boolean;
    /**
     * @hidden
     * List of matched suggestions
     */
    _suggestions: SelectableOptionItem[];
    /**
     * @hidden
     * Grouped suggestions mapped to array.
     */
    _flatSuggestions: SelectableOptionItem[];
    /** @hidden */
    _fullFlatSuggestions: SelectableOptionItem[];
    /**
     * @hidden
     * List of selected suggestions
     */
    _selectedSuggestions: SelectableOptionItem[];
    /**
     * @hidden
     * Max width of list container
     */
    maxWidth: number;
    /**
     * @hidden
     * Min width of list container
     */
    minWidth: number;
    /**
     * @hidden
     * Need for opening mobile version
     */
    openChange: Subject<boolean>;
    /** @hidden */
    selectedShown$: i0.WritableSignal<boolean>;
    /** @hidden */
    protected readonly multiComboboxConfig: MultiComboboxConfig;
    /** @hidden */
    protected readonly _rangeSelector: RangeSelector;
    /** @hidden */
    protected readonly dialogConfig: DialogConfig<any> | null;
    /** @hidden */
    protected _dataSource: FdpMultiComboboxDataSource<any>;
    /** @hidden */
    private _inputTextValue;
    /** @hidden */
    private _previousInputText;
    /** @hidden */
    private _matchingStrategy;
    /** @hidden */
    private _dsSubscription;
    /** @hidden */
    private _element;
    /**
     * @hidden
     * Keys, that won't trigger the popover's open state, when dispatched on search input.
     */
    private readonly _nonOpeningKeys;
    /** @hidden */
    private _timerSub$;
    /** @hidden */
    private _previousState?;
    /** @hidden */
    private _previousStateMessage;
    /** @hidden */
    private readonly _mapLimit;
    /** @hidden */
    private readonly _langSignal;
    /** @hidden */
    private _translationResolver;
    /** @hidden */
    protected constructor();
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** write value for ControlValueAccessor */
    writeValue(value: any): void;
    /** @hidden */
    popoverOpenChangeHandle(isOpen: boolean): void;
    /** @hidden */
    _onOpenChange(isOpen: boolean): void;
    /** Opens the select popover body. */
    open(): void;
    /** Closes the select popover body. */
    close(): void;
    /** @hidden */
    showList(isOpen: boolean): void;
    /** @hidden */
    searchTermChanged(text?: string): void;
    /**
     * Handle Click on Button
     * @hidden
     */
    onPrimaryButtonClick(isOpen: boolean): void;
    /**
     * Handle Keydown on Input
     * @hidden
     */
    onInputKeydownHandler(event: KeyboardEvent): void;
    /** Method passed to list component */
    handleListFocusEscape(direction: FocusEscapeDirection): void;
    /** @hidden */
    setLimitless(limitless: boolean): void;
    /** @hidden */
    getMapLimit(): number;
    /**
     * @hidden
     * Method to emit change event
     */
    _emitChangeEvent(): void;
    /**
     * Used to change the value of a control.
     * @param value the value to be applied
     * @param emitOnChange whether to emit "onChange" event.
     * Should be "false", if the change is made programmatically (internally) by the control, "true" otherwise
     */
    protected setValue(value: any, emitOnChange?: boolean): void;
    /** @hidden */
    protected _setSelectedSuggestions(): void;
    /** @hidden */
    protected get ds(): MultiComboBoxDataSource<any>;
    /** @hidden */
    protected _focusToSearchField(): void;
    /** @hidden */
    protected _getSelectItemByInputValue(displayValue: string): SelectableOptionItem | undefined;
    /** @hidden
     *  Map grouped values to array. */
    protected _flattenGroups(items: SelectableOptionItem[]): SelectableOptionItem[];
    /**
     * Convert object[] data to Group OptionItems Interface
     * @hidden
     */
    protected _convertObjectsToGroupOptionItems<K>(items: K[]): SelectableOptionItem[];
    /** @hidden */
    private _displayFn;
    /** @hidden */
    private _secondaryFn;
    /** @hidden
     * Method that picks other value moved from current one by offset, called only when Multi Combobox is closed */
    private _chooseOtherItem;
    /** @hidden */
    private _initializeDataSource;
    /** @hidden */
    private _openDataStream;
    /** @hidden */
    private _processingEmptyData;
    /** @hidden */
    private _setInvalidEntry;
    /** @hidden */
    private _unsetInvalidEntry;
    /** @hidden */
    private _toDataStream;
    /** @hidden */
    private _initWindowResize;
    /** @hidden */
    private _getOptionsListWidth;
    /**
     * Convert original data to SelectableOptionItems Interface
     * @hidden
     */
    private _convertToOptionItems;
    /**
     * Convert data to SelectableOptionItems Interface
     * @hidden
     */
    private _convertObjectsToOptionItems;
    /**
     * Convert object[] data to Secondary SelectableOptionItems Interface
     * @hidden
     */
    private _convertObjectsToSecondaryOptionItems;
    /**
     * Convert Primitive data(Boolean, String, Number) to SelectableOptionItems Interface
     * @hidden
     */
    private _convertPrimitiveToOptionItems;
    /**
     * Convert object[] to SelectableOptionItems Interface (Default)
     * @hidden
     */
    private _convertObjectsToDefaultOptionItems;
    /**
     * @hidden
     * Assign custom templates
     */
    private _assignCustomTemplates;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMultiCombobox, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseMultiCombobox, never, never, { "selectedItems": { "alias": "selectedItems"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; "entityClass": { "alias": "entityClass"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "group": { "alias": "group"; "required": false; }; "groupKey": { "alias": "groupKey"; "required": false; }; "secondaryKey": { "alias": "secondaryKey"; "required": false; }; "showSecondaryText": { "alias": "showSecondaryText"; "required": false; }; "secondaryTextAlignment": { "alias": "secondaryTextAlignment"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "value": { "alias": "value"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "addonIconTitle": { "alias": "addonIconTitle"; "required": false; }; "invalidEntryMessage": { "alias": "invalidEntryMessage"; "required": false; }; "limitless": { "alias": "limitless"; "required": false; }; "openDropdownOnAddOnClicked": { "alias": "openDropdownOnAddOnClicked"; "required": false; }; }, { "selectionChange": "selectionChange"; "isOpenChange": "isOpenChange"; "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; "addOnButtonClicked": "addOnButtonClicked"; }, ["customTemplates"], never, true, never>;
}

declare const MULTICOMBOBOX_COMPONENT: InjectionToken<string[]>;
/**
 * Combobox Interface to have typing and avoid circular dependency between
 * MultiComboboxComponent <==> MultiComboboxMobileComponent
 */
interface MultiComboboxInterface extends MobileMode {
    _suggestions: SelectableOptionItem[];
    _selectedSuggestions: SelectableOptionItem[];
    selectedShown$: WritableSignal<boolean>;
    openChange: Subject<boolean>;
    moreClicked(): void;
    dialogApprove(): void;
    dialogDismiss(backup: SelectableOptionItem[]): void;
    searchTermChanged(term?: string): void;
}

declare class MultiComboboxMobileComponent extends MobileModeBase<MultiComboboxInterface> implements OnInit {
    /** @hidden */
    dialogTemplate: TemplateRef<any>;
    /** @hidden
     * For internal usage
     * Control element, which will be rendered inside dialog.
     * List element, which will be rendered inside dialog.
     */
    childContent: Nullable<{
        listTemplate: TemplateRef<any>;
        controlTemplate: TemplateRef<any>;
    }>;
    /** @hidden */
    selectedShown$: i0.WritableSignal<boolean>;
    /** @hidden */
    private _selectedBackup;
    /** @hidden */
    constructor(multiComboboxComponent: MultiComboboxInterface);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    showSelected(): void;
    /** @hidden */
    handleDismiss(): void;
    /** @hidden */
    handleApprove(): void;
    /** @hidden */
    private _toggleDialog;
    /** @hidden */
    private _listenOnMultiComboboxOpenChange;
    /** @hidden */
    private _open;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiComboboxMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiComboboxMobileComponent, "fdp-multi-combobox-mobile", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformMultiComboboxMobileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformMultiComboboxMobileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformMultiComboboxMobileModule, never, [typeof MultiComboboxMobileComponent], [typeof MultiComboboxMobileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformMultiComboboxMobileModule>;
}

/**
 * This component can work with both string primitives as well as with complex objects. In order
 * to use objects user must provide an unique ID to lookupkey, which will be used in comparing
 * each items of array. It is important to provide lookupkey value as there might be multiple
 * items with same name but different properties which is to be differently identified otherwise
 * it will be treated as same objects.
 */
declare class MultiComboboxComponent extends BaseMultiCombobox implements OnInit, AfterViewInit {
    readonly _dynamicComponentService: DynamicComponentService;
    private _providers;
    private readonly _viewContainerRef;
    private readonly _injector;
    readonly contentDensityObserver: ContentDensityObserver;
    /** @hidden */
    mobileControlTemplate: TemplateRef<any>;
    /** @hidden */
    listTemplate: TemplateRef<any>;
    /** @hidden */
    _tokenizer: TokenizerComponent;
    /**
     * @hidden
     * List of selected suggestions
     */
    _selectedSuggestions: SelectableOptionItem[];
    /** @hidden */
    constructor(_dynamicComponentService: DynamicComponentService, _providers: Map<string, DataProvider<any>>, _viewContainerRef: ViewContainerRef, _injector: Injector, contentDensityObserver: ContentDensityObserver);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    toggleSelection(item: SelectableOptionItem): void;
    /** @hidden */
    onOptionCheckboxClicked(event: MouseEvent, index: number): void;
    /** @hidden */
    onCompleteTerm(event: AutoCompleteEvent): void;
    /** @hidden */
    toggleSelectionByInputText(text?: string): void;
    /**
     * @hidden
     * Method that selects all possible options.
     * *select* attribute – if *true* select all, if *false* unselect all
     * */
    handleSelectAllItems(select: boolean): void;
    /** @hidden */
    navigateByTokens(event: KeyboardEvent): void;
    /** @hidden */
    removeToken(token: SelectableOptionItem, event?: MouseEvent): void;
    /** @hidden */
    moreClicked(): void;
    /** @hidden */
    onBlur(event: FocusEvent): void;
    /**
     * @hidden
     * Method to set input text as item label.
     */
    setInputTextFromOptionItem(item: OptionItem): void;
    /** @hidden */
    onItemKeyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    onOptionClicked(event: MouseEvent, index: number): void;
    /** @hidden */
    _addOnClicked(event: Event): void;
    /** @hidden Handle dialog dismissing, closes popover and sets backup data. */
    dialogDismiss(backup: SelectableOptionItem[]): void;
    /** @hidden Handle dialog approval, closes popover and propagates data changes. */
    dialogApprove(): void;
    /**
     * @hidden
     * applying range selection. Note, that this function will be invoked after combobox item's value has been changed
     */
    private _onListElementClicked;
    /** @hidden */
    private _getTokenIndexByIdlOrValue;
    /** @hidden */
    private _mapAndUpdateModel;
    /** @hidden */
    private _propagateChange;
    /** @hidden */
    private _setUpMobileMode;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiComboboxComponent, [null, { optional: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiComboboxComponent, "fdp-multi-combobox", never, {}, {}, never, ["*", "*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformMultiComboboxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformMultiComboboxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformMultiComboboxModule, never, [typeof MultiComboboxComponent], [typeof MultiComboboxComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformMultiComboboxModule>;
}

/**
 * Default options for Multi-Input
 */
declare class MultiInputConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /**
     * String matching strategy for typeahead list. Default: 'starts with per term'
     */
    matchingStrategy: MatchingStrategy;
    /**
     * Maps data providers
     */
    providers: Map<string, DataProvider<any>> | null;
    /** @hidden */
    constructor(platformConfig: PlatformConfig);
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<MultiInputConfig>): (platformConfig: PlatformConfig) => MultiInputConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiInputConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MultiInputConfig>;
}

type FdpMultiInputDataSource<T> = MultiInputDataSource<T> | Observable<T[]> | T[];
declare abstract class BaseMultiInput extends CollectionBaseInput implements AfterViewInit, OnChanges, OnDestroy {
    /** @hidden */
    abstract controlTemplate: TemplateRef<any>;
    /** @hidden */
    abstract listTemplate: TemplateRef<any>;
    /**
     * @hidden
     * Define is this item selected
     */
    abstract isSelectedOptionItem(selectedItem: MultiInputOption): boolean;
    /**
     * @hidden
     * Emit select OptionItem
     * */
    abstract selectOptionItem(item: MultiInputOption): void;
    /**
     * @hidden
     * Define value as selected
     * */
    abstract setAsSelected(item: MultiInputOption[]): void;
    /**
     * @hidden
     * Mathod for marking list option as selected.
     */
    abstract _markListItemsAsSelected(): void;
    /** Provides maximum height for the optionPanel */
    maxHeight: string;
    /** Datasource for suggestion list */
    set dataSource(value: FdpMultiInputDataSource<any>);
    get dataSource(): FdpMultiInputDataSource<any>;
    /** Whether the autocomplete should be enabled; Enabled by default */
    autoComplete: boolean;
    /**
     * Todo: Name of the entity for which DataProvider will be loaded. You can either pass list of
     * items or use this entityClass and internally we should be able to do lookup to some registry
     * and retrieve the best matching DataProvider that is set on application level
     */
    entityClass: string;
    /** Whether the Multi Input should be built on mobile mode */
    mobile: boolean;
    /** Multi Input Mobile Configuration, it's applied only, when mobile is enabled */
    mobileConfig: MobileModeConfig;
    /**
     * Whether AddOn Button should be focusable
     * @default false
     */
    buttonFocusable: boolean;
    /** Tells the multi input if we need to group items */
    group: boolean;
    /** A field name to use to group data by (support dotted notation) */
    groupKey?: string;
    /** The field to show data in secondary column */
    description?: string;
    /** The field to show avatar image data in secondary column */
    avatarsrc?: string;
    /** Show the second column (Applicable for two columns layout) */
    showSecondaryText: boolean;
    /** Horizontally align text inside the second column (Applicable for two columns layout) */
    secondaryTextAlignment: TextAlignment;
    /** Turns on/off Adjustable Width feature */
    autoResize: boolean;
    /** Whether to open the dropdown when the addon button is clicked. */
    openDropdownOnAddOnClicked: boolean;
    /** Value of the multi input */
    set value(value: any);
    get value(): any;
    /** @hidden Emits event when the menu is opened/closed */
    readonly isOpenChange: EventEmitter<boolean>;
    /** Event emitted when data loading is started. */
    readonly onDataRequested: EventEmitter<void>;
    /** Event emitted when data loading is finished. */
    readonly onDataReceived: EventEmitter<void>;
    /** Event emitted when the search term changes. Use *$event* to access the new term. */
    readonly searchTermChange: EventEmitter<string>;
    /** Emits event when the addon button is clicked. */
    readonly addOnButtonClicked: EventEmitter<Event>;
    /** @hidden */
    listComponent: ListComponent$1<MultiInputOption>;
    /** @hidden */
    customTemplates: QueryList<TemplateDirective>;
    /** @hidden */
    searchInputElement: ElementRef;
    /** @hidden
     * Custom Option item Template
     * */
    optionItemTemplate: TemplateRef<any>;
    /** @hidden
     * Custom Group Header item Template
     * */
    groupItemTemplate: TemplateRef<any>;
    /** @hidden
     * Custom Secondary item Template
     * */
    secondaryItemTemplate: TemplateRef<any>;
    /** @hidden
     * Custom Selected option item Template
     * */
    selectedItemTemplate: TemplateRef<any>;
    /** input text of the input. */
    inputText: string;
    /** Whether the Multi Input is opened. */
    isOpen: boolean;
    /** @hidden */
    get canClose(): boolean;
    /**
     * @hidden
     * List of matched suggestions
     * */
    _suggestions: MultiInputOption[];
    /** @hidden
     * List of matched suggestions
     * */
    _newSuggestions: MultiInputOption[];
    /** @hidden
     * Max width of list container
     * */
    maxWidth?: number;
    /** @hidden
     * Min width of list container
     * */
    minWidth?: number;
    /**
     * Need for opening mobile version
     *
     * @hidden
     */
    openChange: Subject<boolean>;
    /** @hidden */
    protected readonly multiInputConfig: MultiInputConfig;
    /** @hidden */
    protected _dataSource: FdpMultiInputDataSource<any>;
    /** @hidden */
    protected readonly dialogConfig: DialogConfig<any> | null;
    /** @hidden emits whenever there're changes to the inputs, that affect the data creation from data source */
    private readonly _updateDataSourceValues$;
    /** @hidden */
    private _matchingStrategy;
    /** @hidden */
    private _dsSubscription?;
    /** @hidden */
    private _element;
    /** Keys, that won't trigger the popover's open state, when dispatched on search input */
    private readonly _nonOpeningKeys;
    /** @hidden */
    private _originalSuggestions;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** write value for ControlValueAccessor */
    writeValue(value: any): void;
    /** @hidden */
    _popoverOpenChangeHandle(isOpen: boolean): void;
    /** Opens the select popover body. */
    open(): void;
    /** Closes the select popover body. */
    close(): void;
    /** @hidden */
    convertObjectToMultiInputOption(items: any[]): MultiInputOption[];
    /** @hidden */
    searchTermChanged(text?: string): void;
    /** @hidden */
    showList(isOpen: boolean): void;
    /** @hidden */
    handleOptionItem(value: MultiInputOption): void;
    /** @hidden */
    handlePressEnter(event: KeyboardEvent, value: MultiInputOption): void;
    /**
     * Handle Keydown on Input
     * @hidden
     */
    onInputKeydownHandler(event: KeyboardEvent): void;
    /** Method passed to list component */
    handleListFocusEscape(direction: FocusEscapeDirection): void;
    /** @hidden */
    private _displayFn;
    /** @hidden */
    private _secondaryFn;
    /** @hidden */
    protected get ds(): MultiInputDataSource<any>;
    /** @hidden
     * Method that picks other value moved from current one by offset, called only when Multi Input is closed */
    private _chooseOtherItem;
    /** @hidden */
    private _initializeDataSource;
    /** @hidden */
    private _openDataStream;
    /** @hidden */
    private _toDataStream;
    /** @hidden */
    private _initWindowResize;
    /** @hidden */
    private _getOptionsListWidth;
    /**
     * Convert original data to OptionItems Interface
     * @hidden
     */
    private _convertToOptionItems;
    /**
     * Convert data to OptionItems Interface
     * @hidden
     */
    private _convertObjectsToOptionItems;
    /**
     * Convert object[] data to Group OptionItems Interface
     * @hidden
     */
    private _convertObjectsToGroupOptionItems;
    /**
     * Convert object[] data to Secondary OptionItems Interface
     * @hidden
     */
    private _convertObjectsToSecondaryOptionItems;
    /**
     * Convert Primitive data(Boolean, String, Number) to OptionItems Interface
     * @hidden
     */
    private _convertPrimitiveToOptionItems;
    /**
     * Convert object[] to OptionItems Interface (Default)
     * @hidden
     */
    private _convertObjectsToDefaultOptionItems;
    /** @hidden
     * Assign custom templates
     * */
    private _assignCustomTemplates;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMultiInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseMultiInput, never, never, { "maxHeight": { "alias": "maxHeight"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; "entityClass": { "alias": "entityClass"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; }; "group": { "alias": "group"; "required": false; }; "groupKey": { "alias": "groupKey"; "required": false; }; "description": { "alias": "description"; "required": false; }; "avatarsrc": { "alias": "avatarsrc"; "required": false; }; "showSecondaryText": { "alias": "showSecondaryText"; "required": false; }; "secondaryTextAlignment": { "alias": "secondaryTextAlignment"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "openDropdownOnAddOnClicked": { "alias": "openDropdownOnAddOnClicked"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "isOpenChange": "isOpenChange"; "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; "searchTermChange": "searchTermChange"; "addOnButtonClicked": "addOnButtonClicked"; }, ["customTemplates"], never, true, never>;
}

declare const MULTIINPUT_COMPONENT: InjectionToken<string[]>;
interface PlatformMultiInputInterface extends MobileMode {
    _selected: any[];
    openChange: Subject<boolean>;
    _dialogApprove(): void;
    _dialogDismiss(selectedBackup: any[]): void;
}

declare class PlatformMultiInputMobileComponent extends MobileModeBase<PlatformMultiInputInterface> implements OnInit {
    /** @hidden */
    dialogTemplate: TemplateRef<any>;
    /** @hidden
     * For internal usage
     * Control element, which will be rendered inside dialog.
     * List element, which will be rendered inside dialog.
     */
    childContent: Nullable<{
        listTemplate: TemplateRef<any>;
        controlTemplate: TemplateRef<any>;
    }>;
    /** @hidden */
    private _selectedBackup;
    /** @hidden */
    constructor(multiInputComponent: PlatformMultiInputInterface);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    _handleApprove(): void;
    /** @hidden */
    _handleDismiss(): void;
    /** @hidden */
    private _listenOnMultiInputOpenChange;
    /** @hidden */
    private _toggleDialog;
    /** @hidden */
    private _open;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformMultiInputMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformMultiInputMobileComponent, "fdp-multi-input-mobile", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformMultiInputMobileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformMultiInputMobileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformMultiInputMobileModule, never, [typeof PlatformMultiInputMobileComponent], [typeof PlatformMultiInputMobileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformMultiInputMobileModule>;
}

declare class MultiInputSelectionChangeEvent {
    source: PlatformMultiInputComponent;
    payload: any;
    /**
     * Multi Input selection change event
     * @param source Multi Input component
     * @param payload Selected value
     */
    constructor(source: PlatformMultiInputComponent, payload: any);
}
declare class PlatformMultiInputComponent extends BaseMultiInput implements OnInit, AfterViewInit {
    /** @hidden */
    readonly _dynamicComponentService: DynamicComponentService;
    /** @hidden */
    private readonly _viewContainerRef;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private _providers;
    readonly contentDensityObserver: ContentDensityObserver;
    /** @hidden TODO: remove when permanently deleting the deprecated tokenHiddenId input */
    protected tokenCountHiddenLabel: string;
    /** @deprecated Now handled internally by tokenizer. */
    tokenHiddenId: string;
    /** type Represent the type of input used for the multi Input */
    type: InputType;
    /** boolean type represents the focus set for the respective multi input */
    autofocus: boolean;
    /**  */
    glyphAriaLabel: string;
    /** Title text for the add-on icon button. */
    addonIconTitle: string;
    /** @hidden */
    listTemplateDD: ListComponent$1<MultiInputOption>;
    /** Selected values from the list items. */
    _selected: any[];
    /** Selected items of the multi input. */
    set selected(selectedValue: any[]);
    get selected(): any[];
    /**
     *
     */
    selectionMode: SelectionType;
    /** Whether the list in byline mode. */
    hasByLine: boolean;
    /** @hidden */
    selectedValue?: MultiInputOption;
    /** @hidden */
    get isGroup(): boolean;
    /** @hidden Whether the input is disabled. */
    protected _disabled: boolean;
    /** Whether the multi input is disabled. */
    set disabled(value: boolean);
    get disabled(): boolean;
    /**
     * Preset options for the Select body width, whatever is chosen, the body has a 600px limit.
     * `at-least` will apply a minimum width to the body equivalent to the width of the control. - Default
     * `equal` will apply a width to the body equivalent to the width of the control.
     * 'fit-content' will apply width needed to properly display items inside, independent of control.
     */
    fillControlMode: PopoverFillMode;
    /**
     * The trigger events that will open/close the options popover.
     * Accepts any [HTML DOM Events](https://www.w3schools.com/jsref/dom_obj_event.asp).
     */
    triggers: string[];
    /** Whether the combobox should close, when a click is performed outside its boundaries. True by default */
    closeOnOutsideClick: boolean;
    /** Callback function when add-on button clicked. */
    addOnButtonClickFn: () => void;
    /** Event emitted when item is selected. */
    readonly selectionChange: EventEmitter<MultiInputSelectionChangeEvent>;
    /** @hidden */
    tokenizer: TokenizerComponent;
    /** @hidden */
    controlTemplate: TemplateRef<any>;
    /** @hidden */
    listTemplate: TemplateRef<any>;
    /** @hidden */
    private readonly _listItems;
    /** @hidden */
    constructor(
    /** @hidden */
    _dynamicComponentService: DynamicComponentService, 
    /** @hidden */
    _viewContainerRef: ViewContainerRef, 
    /** @hidden */
    _injector: Injector, 
    /** @hidden */
    _providers: Map<string, DataProvider<any>>, contentDensityObserver: ContentDensityObserver);
    /** Display function. Accepts an object of the same type as the
     * items passed to dropdownValues as argument, and outputs a string.
     * An arrow function can be used to access the *this* keyword in the calling component.
     * See multi input examples for details. */
    displayFn: (str: string) => string;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden Method to emit change event */
    emitChangeEvent<T>(modelValue: T): void;
    /** @hidden */
    _checkboxSelected(value: any, event: ModifyItemEvent): void;
    /** @hidden */
    addToArray(value: any, focusOnInput?: boolean): void;
    /** @hidden */
    addOnButtonClick(event: Event): void;
    /** @hidden */
    onInputGroupClicked(): void;
    /** @hidden */
    moreClicked(): void;
    /** @hidden */
    deleteToken(selectedValue: MultiInputOption): void;
    /** @hidden */
    removeToken(token: any): void;
    /** @hidden */
    removeSelectedTokens(event: KeyboardEvent): void;
    /** @hidden Define is selected item selected */
    isSelectedOptionItem(selectedItem: any): boolean;
    /** @hidden Method to set selected item */
    selectOptionItem(item: MultiInputOption): void;
    /** @hidden Method to set as selected */
    setAsSelected(item: MultiInputOption[]): void;
    /**
     * @hidden
     * Mathod for marking items in dropdown as selected.
     */
    _markListItemsAsSelected(): void;
    /** @hidden */
    _onAutoComplete(event: AutoCompleteEvent): void;
    /** @hidden */
    _onKeydownEnter(event: Event): void;
    /** @hidden Handle dialog dismissing, closes popover and sets backup data. */
    _dialogDismiss(selected: any[]): void;
    /** @hidden Handle dialog approval, closes popover and propagates data changes. */
    _dialogApprove(): void;
    /** @hidden if not selected update model */
    private _checkAndUpdate;
    /** @hidden */
    private _getSelectedOptionItem;
    /** @hidden Update model */
    private _updateModel;
    /** @hidden */
    private _setUpMobileMode;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformMultiInputComponent, [null, null, null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformMultiInputComponent, "fdp-multi-input", never, { "tokenHiddenId": { "alias": "tokenHiddenId"; "required": false; }; "type": { "alias": "type"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "glyphAriaLabel": { "alias": "glyphAriaLabel"; "required": false; }; "addonIconTitle": { "alias": "addonIconTitle"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "hasByLine": { "alias": "hasByLine"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "addOnButtonClickFn": { "alias": "addOnButtonClickFn"; "required": false; }; "displayFn": { "alias": "displayFn"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, ["*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformMultiInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformMultiInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformMultiInputModule, never, [typeof PlatformMultiInputComponent], [typeof PlatformMultiInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformMultiInputModule>;
}

declare class RadioButtonComponent extends BaseInput implements AfterViewInit, FocusableOption {
    /** sets radio button tooltip */
    title: string;
    /**
     * Includes the Radio in the page tab sequence.
     */
    tabIndex: number;
    /** value for Radio button */
    set value(newValue: any);
    get value(): any;
    /** used for radio button creation if list value present */
    forceRender: boolean;
    /** reference of template */
    renderer: TemplateRef<any>;
    /** click event to emit */
    readonly checked: EventEmitter<RadioButtonComponent>;
    /** Access radio button child element passed as content of radio button group */
    private coreRadioButton;
    /** @hidden */
    _currentValue: any;
    /** @hidden Radio checked status */
    _isChecked: boolean;
    /** @hidden */
    constructor();
    /** @hidden Controlvalue accessor */
    writeValue(value: any): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    _valueChange(value: any, emitEvent?: boolean): void;
    /** method for cdk FocusKeymanager */
    focus(): void;
    /** method to select radio button */
    select(): void;
    /** method to uncheck radio button */
    unselect(): void;
    /** Setting tabIndex for radio accessibility */
    setTabIndex(index: 0 | -1): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "fdp-radio-button", never, { "title": { "alias": "title"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "value": { "alias": "value"; "required": false; }; "forceRender": { "alias": "forceRender"; "required": false; }; }, { "checked": "checked"; }, never, ["*"], true, never>;
}

declare class RadioGroupComponent extends InLineLayoutCollectionBaseInput implements AfterViewInit, AfterContentChecked, OnDestroy {
    /** Value of selected radio button */
    set value(newValue: any);
    get value(): any;
    /** To Display Radio buttons in a line */
    set isInline(inline: boolean);
    get isInline(): boolean;
    /** None value radio button created */
    hasNoValue: boolean;
    /** Label for None value radio button */
    noValueLabel: string;
    /** Children radio buttons part of Group radio button, passed as content */
    contentRadioButtons: QueryList<RadioButtonComponent>;
    /** Children radio buttons part of Group radio button, created from list of values */
    viewRadioButtons: QueryList<RadioButtonComponent>;
    /** Selected radio button change event raised */
    change: EventEmitter<RadioButtonComponent>;
    /** @hidden */
    private _activeItemSet;
    /** @hidden The currently selected radio button. Should match value. */
    private _selected;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden FocusKeyManager instance */
    private _keyboardEventsManager;
    /** @hidden */
    constructor();
    /** @hidden */
    _handleKeydown(event: KeyboardEvent): void;
    /** Control Value Accessor */
    writeValue(value: any): void;
    /** Access display value for objects, acts as checkbox label. */
    getDisplayValue(item: any): string;
    /**
     * Called on button click for view radio button, created from list of values
     * @param event
     */
    selected(event: RadioButtonComponent): void;
    /** @hidden Selecting default button as provided as input */
    ngAfterContentChecked(): void;
    /**
     * @hidden
     * Initialize properties once fd-radio-buttons are available.
     * This allows us to propagate relevant attributes to associated buttons.
     */
    ngAfterViewInit(): void;
    /** @hidden Destroys event subscription. */
    ngOnDestroy(): void;
    /** @hidden */
    _getListItemDisabledValue(item: RadioGroupComponent['list'][number]): boolean;
    /** @hidden */
    private _initialSetup;
    /**
     * @hidden
     * Selects given button, if value matches
     * @param button
     */
    private _selectUnselect;
    /** @hidden Called every time a radio button is clicked, In content child as well as viewchild */
    private _selectedValueChanged;
    /** @hidden resets tabIndex for first radio in radio group. for accessibility tabIndex was set */
    private _resetTabIndex;
    /**
     * @hidden
     * @param button Set initial values, used while content children creation
     */
    private _setProperties;
    /** @hidden Make sure we have expected child. */
    private _validateRadioButtons;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "fdp-radio-group", never, { "value": { "alias": "selected"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "hasNoValue": { "alias": "hasNoValue"; "required": false; }; "noValueLabel": { "alias": "noValueLabel"; "required": false; }; }, { "change": "change"; }, ["contentRadioButtons"], never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformRadioGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformRadioGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformRadioGroupModule, never, [typeof RadioGroupComponent, typeof RadioButtonComponent], [typeof RadioGroupComponent, typeof RadioButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformRadioGroupModule>;
}

interface SelectOptionItem extends OptionItem {
    icon?: string;
    disabled?: boolean;
}

/**
 * Default options for Combobox
 */
declare class SelectConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /** @hidden */
    constructor(platformConfig: PlatformConfig);
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<SelectConfig>): (platformConfig: PlatformConfig) => SelectConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectConfig>;
}

type FdpSelectData<T> = SelectOptionItem[] | Observable<T[]> | T[];
/**
 * @deprecated
 * `FdpSelectionChangeEvent` will be removed in future versions in favour of plain value emission
 */
declare class FdpSelectionChangeEvent {
    payload: any;
    /**
     * Select selection change event
     * @param payload selected value
     */
    constructor(payload: any);
}
declare abstract class BaseSelect extends CollectionBaseInput implements SingleDropdownValueControl, AfterViewInit, OnDestroy {
    /** Provides maximum default height for the optionPanel */
    maxHeight: string;
    /** Whether the select should be built on mobile mode */
    mobile: boolean;
    /** Tells the select if we need to group items */
    group: boolean;
    /** A field name to use to group data by (support dotted notation) */
    groupKey?: string;
    /** The field to show data in secondary column */
    secondaryKey?: string;
    /** Show the second column (Applicable for two columns layout) */
    showSecondaryText: boolean;
    /** Glyph to add icon in the select component. */
    glyph: string;
    /** Glyph font family */
    glyphFont: IconFont;
    /** The element to which the popover should be appended. */
    appendTo: ElementRef;
    /** Trigger value */
    triggerValue: string;
    /**
     * Preset options for the select body width.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control.
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * Leave blank for no effect.
     */
    fillControlMode: PopoverFillMode;
    /** Horizontally align text inside the second column (Applicable for two columns layout) */
    secondaryTextAlignment: TextAlignment;
    /**
     * Max width of list container
     * */
    width: string;
    /** Whether the select component is readonly. */
    readonly: boolean;
    /** Placeholder for the select. Appears in the
     * triggerbox if no option is selected. */
    placeholder: string;
    /** Whether close the popover on outside click. */
    closeOnOutsideClick: boolean;
    /** Custom template used to build control body. */
    controlTemplate: TemplateRef<any> | undefined;
    /** Select Input Mobile Configuration */
    mobileConfig: MobileModeConfig;
    /**
     * String rendered as first value in the popup which let the user to make 'no selection' from
     * available list of values. When this option is active and use make this selection we save a
     * NULL value
     */
    noValueLabel: string;
    /** Whether not to wrap text */
    noWrapText: boolean;
    /** Turns on/off Adjustable Width feature */
    autoResize: boolean;
    /** First Column ratio */
    set firstColumnRatio(value: number);
    get firstColumnRatio(): number;
    /** Secoond Column ratio */
    set secondColumnRatio(value: number);
    get secondColumnRatio(): number;
    /**
     * Min width of list container
     *
     * */
    minWidth?: number;
    /**
     * Max width of list container
     * */
    maxWidth?: number;
    /**
     * Action to perform when user shifts focus from the dropdown.
     * - `close` will close the dropdown preserving previously selected value.
     * - `closeAndSelect` will close the dropdown and select last focused dropdown item.
     */
    tabOutStrategy: 'close' | 'closeAndSelect';
    /** Data for suggestion list */
    set list(value: any);
    get list(): any;
    /** @hidden */
    get canClose(): boolean;
    /** Event emitted when item is selected. */
    selectionChange: EventEmitter<FdpSelectionChangeEvent>;
    /** @hidden */
    listComponent: ListComponent;
    /** @hidden */
    customTemplates: QueryList<TemplateDirective>;
    /** Custom Option item Template
     * * @hidden
     * */
    _optionItemTemplate: TemplateRef<any>;
    /**
     * Custom Secondary item Template
     * @hidden
     * */
    _secondaryItemTemplate: TemplateRef<any>;
    /**
     * Custom Selected option item Template
     * @hidden
     * */
    _selectedItemTemplate: TemplateRef<any>;
    /** @hidden */
    _contentDensityService: ContentDensityService;
    /**
     * List of option items
     * @hidden
     * */
    _optionItems: SelectOptionItem[];
    /** @hidden */
    _subscriptions: Subscription;
    /** @hidden */
    protected readonly selectConfig: SelectConfig;
    /** @hidden */
    private _searchInputElement;
    /** Whether the select is opened. */
    private _isOpen;
    /**
     * Need for opening mobile version
     *
     * @hidden
     */
    private _openChange;
    /** @hidden */
    private _dsSubscription?;
    /** @hidden */
    private _element;
    /** @hidden */
    private _firstColumnRatio;
    /** @hidden */
    private _secondColumnRatio;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Is empty search field */
    get isEmptyValue(): boolean;
    /** @hidden
     * Close list * */
    close(event?: MouseEvent | null, forceClose?: boolean): void;
    /** @hidden */
    showList(isOpen: boolean): void;
    /** @hidden */
    handlePressEnter(event: KeyboardEvent, value: SelectOptionItem): void;
    /** Method passed to list component */
    handleListFocusEscape(direction: FocusEscapeDirection): void;
    /** @hidden */
    protected setValue(newValue: any, emitOnChange?: boolean): void;
    /** @hidden */
    private _initWindowResize;
    /** @hidden */
    private _getOptionsListWidth;
    /**
     * Convert original data to OptionItems Interface
     * @hidden
     */
    private _convertToOptionItems;
    /**
     * Convert data to OptionItems Interface
     * @hidden
     */
    private _convertObjectsToOptionItems;
    /**
     * Convert object[] data to Secondary OptionItems Interface
     * @hidden
     */
    private _convertObjectsToSecondaryOptionItems;
    /**
     * Convert Primitive data(Boolean, String, Number) to OptionItems Interface
     * @hidden
     */
    private _convertPrimitiveToOptionItems;
    /**
     * Convert object[] to OptionItems Interface (Default)
     * @hidden
     */
    private _convertObjectsToDefaultOptionItems;
    /** @hidden
     * Assign custom templates
     * */
    private _assignCustomTemplates;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSelect, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSelect, never, never, { "maxHeight": { "alias": "maxHeight"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "group": { "alias": "group"; "required": false; }; "groupKey": { "alias": "groupKey"; "required": false; }; "secondaryKey": { "alias": "secondaryKey"; "required": false; }; "showSecondaryText": { "alias": "showSecondaryText"; "required": false; }; "glyph": { "alias": "glyph"; "required": false; }; "glyphFont": { "alias": "glyphFont"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "triggerValue": { "alias": "triggerValue"; "required": false; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; }; "secondaryTextAlignment": { "alias": "secondaryTextAlignment"; "required": false; }; "width": { "alias": "width"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "controlTemplate": { "alias": "controlTemplate"; "required": false; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "noValueLabel": { "alias": "noValueLabel"; "required": false; }; "noWrapText": { "alias": "noWrapText"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "firstColumnRatio": { "alias": "firstColumnRatio"; "required": false; }; "secondColumnRatio": { "alias": "secondColumnRatio"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "tabOutStrategy": { "alias": "tabOutStrategy"; "required": false; }; "list": { "alias": "list"; "required": false; }; }, { "selectionChange": "selectionChange"; }, ["customTemplates"], never, true, never>;
}

declare class SelectComponent extends BaseSelect implements AfterViewInit, AfterViewChecked {
    /**
     * Directly sets value to the component that at the ends up at writeValue as well fires
     * change detections
     */
    set value(newValue: any);
    get value(): any;
    /** Should select be inlined. */
    inline: boolean;
    /** @hidden */
    select: SelectComponent$1;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngAfterViewChecked(): void;
    /**
     * Define is selected item selected
     * @hidden
     */
    _isSelectedOptionItem(selectedItem: any): boolean;
    /** @hidden */
    _onSelection(value: any): void;
    /** @hidden */
    _onOpenChange(isOpen: boolean): void;
    /** @hidden */
    private _setColumnsRatio;
    /** @hidden */
    private _setOptionAttribute;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "fdp-select", never, { "value": { "alias": "value"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformSelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformSelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformSelectModule, never, [typeof SelectComponent], [typeof SelectComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformSelectModule>;
}

/** Change event object emitted by Platform Step Input component */
declare class StepInputChangeEvent<T extends StepInputComponent = StepInputComponent, K = number> {
    /** The source Step Input of the event. */
    source: T;
    /** The new value of a control. */
    payload: K;
    /**
     * Step input selection change event
     * @param source Step input component
     * @param payload Selected value
     */
    constructor(
    /** The source Step Input of the event. */
    source: T, 
    /** The new value of a control. */
    payload: K);
}
declare enum StepInputAlign {
    Left = "left",
    Center = "center",
    Right = "right"
}
type StepInputStepFunctionAction = 'increase' | 'decrease';
type StepInputStepFunction = (value: number, action: StepInputStepFunctionAction) => number;
/**
 * StepInputComponent is a base abstract class that should be used
 * to create type specific StepInput components such as number, money, unitOfMeasure
 * This holds base Step Input functionality that can be abstracted
 */
declare abstract class StepInputComponent extends BaseInput implements OnInit {
    /** Create valueChange event */
    abstract createChangeEvent(value: number): StepInputChangeEvent;
    /** Format value for view presentation */
    abstract formatValue(value: number | null): string;
    /** Format value for "in focus" mode */
    abstract formatValueInFocusMode(value: number): string;
    /** Parse value entered "in focus" mode */
    abstract parseValueInFocusMode(value: string): number | null;
    /** Sets input value */
    set value(value: Nullable<number>);
    get value(): Nullable<number>;
    /** Sets minimum value boundary */
    set min(min: number);
    get min(): number;
    /** Sets maximum value boundary */
    set max(max: number);
    get max(): number;
    /** Sets input step value */
    set step(step: number);
    get step(): number;
    /** Custom function to calculate step dynamically */
    set stepFn(stepFn: StepInputStepFunction);
    /** Number of digits after the decimal point */
    set precision(precision: number);
    get precision(): number;
    /** Sets largeStep multiplier */
    largerStep: number;
    /** Hides -/+ icons and shows labels */
    showLabels: boolean;
    /** Horizontally aligns value inside input */
    set align(align: StepInputAlign | null);
    get align(): StepInputAlign | null;
    /**
     * ARIA label for increment button
     */
    incrementLabel: string;
    /**
     * ARIA label for decrement button
     */
    decrementLabel: string;
    /** Emits new value when control value has changed */
    valueChange: EventEmitter<StepInputChangeEvent<StepInputComponent, number>>;
    /** @hidden */
    lastEmittedValue: number;
    /** @hidden */
    canIncrement: boolean;
    /** @hidden */
    canDecrement: boolean;
    /** @hidden
     * Indicates if control has an error
     */
    isErrorState: boolean;
    /** @hidden */
    get canChangeValue(): boolean;
    /** @hidden */
    readonly _align$: i0.WritableSignal<StepInputAlign | null>;
    /** @hidden */
    readonly _textAlign$: i0.Signal<StepInputAlign | null>;
    /** @hidden */
    private _max;
    /** @hidden */
    private _min;
    /** @hidden */
    private _step;
    /** @hidden */
    private _stepFn;
    /** @hidden */
    private _precision;
    /** @hidden */
    private _pendingEnteredValue;
    /** @hidden */
    private get _currentValue();
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden
     * Override writeValue method to keep input view value up to date
     */
    writeValue(value: number): void;
    /** Increase value */
    increase(step?: number): void;
    /** Decrease value */
    decrease(step?: number): void;
    /** Increase value by large step */
    largeStepIncrease(): void;
    /** Decrease value by large step */
    largeStepDecrease(): void;
    /** @hidden
     * catch value during entering from view.
     */
    onEnterValue(value: string): void;
    /** @hidden
     * Commit entered value from view.
     */
    commitEnteredValue(): void;
    /** @hidden
     * Indicates when input gets focused
     */
    onFocus(): void;
    /** @hidden
     * Indicates when input loses focus
     */
    onBlur(): void;
    /** @hidden */
    private _listenToFormErrorState;
    /** @hidden */
    private _emitChangedValue;
    /** @hidden */
    private _getStepValueForIncrease;
    /** @hidden */
    private _getStepValueForDecrease;
    /** @hidden
     * Get step value based either on "stepFn" or "step"
     */
    private _getStepValue;
    /** @hidden */
    private _updateViewValue;
    /** @hidden */
    private _formatValue;
    /** @hidden */
    private _renderValue;
    /** @hidden */
    private _getInputNativeElement;
    /** @hidden */
    private _getValueSelection;
    /** @hidden */
    private _setValueSelection;
    /** @hidden */
    private _calculateCanIncrement;
    /** @hidden */
    private _calculateCanDecrement;
    /** @hidden */
    private _calculateCanDecrementIncrement;
    /** @hidden */
    private _validateValueByLimits;
    /** @hidden */
    private _checkAndThrowErrorIfStepDoesntMatchPrecision;
    /** @hidden */
    private _setPendingEnteredValue;
    /** @hidden */
    private _resetPendingEnteredValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StepInputComponent, never, never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "stepFn": { "alias": "stepFn"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "largerStep": { "alias": "largerStep"; "required": false; }; "showLabels": { "alias": "showLabels"; "required": false; }; "align": { "alias": "align"; "required": false; }; "incrementLabel": { "alias": "incrementLabel"; "required": false; }; "decrementLabel": { "alias": "decrementLabel"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

/**
 * Fundamental number-step-input component
 *
 * Example of usage
 * ```html
 * <fdp-number-step-input
 *   name="number"
 *   [value]="value"
 *   (valueChange)="onValueChange($event)"
 * ></fdp-number-step-input>
 * ```
 *
 * */
declare class NumberStepInputComponent extends StepInputComponent {
    readonly localeId: string;
    readonly contentDensityObserver: ContentDensityObserver;
    /** Set description */
    description: string;
    /** @hidden */
    constructor(localeId: string, contentDensityObserver: ContentDensityObserver);
    /** @hidden
     * Create change event instance
     */
    createChangeEvent(value: number): StepInputChangeEvent;
    /** @hidden
     * Format value taking into account LOCALE_ID
     */
    formatValue(value: number | null): string;
    /** @hidden
     * In order to avoid issues trying to parse formatted number
     * (potentially specific for each local)
     * we have to simplify number format once it's in focus mode.
     * In this case we deal with a regular float number
     */
    formatValueInFocusMode(value: number | null): string;
    /** @hidden
     * Used to parse entered value
     */
    parseValueInFocusMode(value: string | null): number | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberStepInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberStepInputComponent, "fdp-number-step-input", never, { "description": { "alias": "description"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * This is a base step input directive to be used for increase/decrease buttons.
 */
declare abstract class StepInputActionButton {
    /**
     * @hidden
     * Indicates if action can be handled
     */
    abstract canHandleAction(): boolean;
    /**
     * @hidden
     * Step input button action handler
     */
    abstract runAction(): void;
    /** @hidden */
    protected _destroyed: DestroyRef;
    /** @hidden */
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputActionButton, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StepInputActionButton, never, never, {}, {}, never, never, true, never>;
}

/**
 * This directive is intendant to be a bridge between input control and BaseStepInput Component.
 */
declare class StepInputControlDirective {
    private stepInput;
    /** @hidden */
    constructor(stepInput: StepInputComponent);
    /**
     * @hidden
     * Handle "input" event to keep track of what user is entering
     */
    onInput(event: Event): void;
    /**
     * @hidden
     * Handle "change" event to commit entered value
     */
    onChange(): void;
    /**
     * @hidden
     * Handle "focus" event
     */
    onFocus(): void;
    /**
     * @hidden
     * Handle "blur" event
     */
    onBlur(): void;
    /**
     * @hidden
     * Handle "keydown" event
     */
    onKeyDown(event: KeyboardEvent): void;
    /**
     * @hidden
     * Handle mouse wheel
     */
    onMouseWheel(event: WheelEvent): void;
    /**
     * @hidden
     * Mute event
     */
    private _muteEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputControlDirective, [{ skipSelf: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StepInputControlDirective, "[fdpStepInputControl]", never, {}, {}, never, never, true, never>;
}

/**
 * This Directive is used to be assigned to decrement button.
 */
declare class StepInputDecrementDirective extends StepInputActionButton {
    private readonly stepInput;
    /** @hidden */
    canHandleAction(): boolean;
    /** @hidden */
    runAction(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputDecrementDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StepInputDecrementDirective, "[fdpStepInputDecrement]", never, {}, {}, never, never, true, never>;
}

/**
 * This Directive is used to be assigned to increment button.
 */
declare class StepInputIncrementDirective extends StepInputActionButton {
    private readonly stepInput;
    /** @hidden */
    canHandleAction(): boolean;
    /** @hidden */
    runAction(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputIncrementDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StepInputIncrementDirective, "[fdpStepInputIncrement]", never, {}, {}, never, never, true, never>;
}

/**
 * Default options for platform step input
 */
declare class StepInputConfig {
    /**
     * ARIA label for increment button
     */
    incrementLabel: string;
    /**
     * ARIA label for decrement button
     */
    decrementLabel: string;
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepInputConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StepInputConfig>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformStepInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformStepInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformStepInputModule, never, [typeof StepInputDecrementDirective, typeof StepInputIncrementDirective, typeof StepInputControlDirective, typeof NumberStepInputComponent], [typeof StepInputDecrementDirective, typeof StepInputIncrementDirective, typeof StepInputControlDirective, typeof NumberStepInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformStepInputModule>;
}

declare const addAndCutFloatingNumberDistortion: (value: number | null, step: number) => number;
declare const getNumberDecimalLength: (value: number) => number;

/**
 * Default options for platform Switch
 */
declare class SwitchConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<SwitchConfig>): () => SwitchConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchConfig>;
}

/** Switch change event instance */
declare class SwitchChangeEvent {
    /** The source Switch of the event. */
    source: SwitchComponent;
    /** The new `payload` value of the switch. */
    payload: boolean;
}
declare class SwitchComponent extends BaseInput {
    protected _switchConfig: SwitchConfig;
    /** Whether the switch is semantic */
    semantic: boolean;
    /**
     * Event fired when the state of the switch changes.
     * *$event* can be used to retrieve the new state of the switch.
     */
    readonly switchChange: EventEmitter<SwitchChangeEvent>;
    /** value for switch control */
    set value(selectValue: any);
    get value(): any;
    /** @hidden
     * tracking switch current value
     */
    switchCurrentValue: boolean;
    /** @hidden */
    constructor(_switchConfig: SwitchConfig);
    /** update controller on switch state change */
    onValueChange(modelValue: boolean): void;
    /** write value for ControlValueAccessor */
    writeValue(value: any): void;
    /** @hidden
     * update model
     */
    private _updateModel;
    /** @hidden
     * Method to emit change event
     */
    private _emitChangeEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "fdp-switch", never, { "semantic": { "alias": "semantic"; "required": false; }; }, { "switchChange": "switchChange"; }, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformSwitchModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformSwitchModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformSwitchModule, never, [typeof SwitchComponent], [typeof SwitchComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformSwitchModule>;
}

/**
 * Default options for platform Text Area
 */
declare class TextAreaConfig {
    /**
     * Content Density of element. 'cozy' | 'compact'
     */
    contentDensity: ContentDensity;
    /**
     * Create Provider factory function
     */
    static createProviderFactory(obj: Partial<TextAreaConfig>): () => TextAreaConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextAreaConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TextAreaConfig>;
}

type WrapType = 'hard' | 'soft' | 'off';
/**
 * Textarea field implementation that is compliant with Platform's FormGroup/FormField design
 *
 */
declare class TextAreaComponent extends BaseInput implements AfterViewChecked, OnInit, AfterViewInit {
    protected _textAreaConfig: TextAreaConfig;
    /**
     * The height to which the textarea will grow when `growing` is set.
     */
    height: Nullable<string>;
    /**
     * The number of rows that will be visible when `growing` is set.
     * If both `growingMaxLines` and `height` are provided, `height` value takes precedence.
     */
    growingMaxLines: Nullable<number>;
    /**
     * The textarea `cols` attribute wrapped- the number of letters visible per line.
     * If width is set to auto, this attribute has no effect.
     */
    cols: number;
    /**
     * The textarea `wrap` attribute - can be one of three: 'off', 'hard' or 'soft'.
     */
    wrapType: WrapType;
    /** The maximum number of characters allowed to enter.
     * If `showExceededText` is false, `maxLength` has native textarea's behavior of disallowing typing beyond `maxLength`.
     * If `showExceededText` is true, user is allowed to type beyond `maxLength`, but error states and counter messages showing
     * the exceeded count is displayed.
     */
    maxLength: number;
    /**
     * Whether counter message should be shown.
     * If `showExceededText` is false, no state changes or error messages are shown. User is simply not allowed to type
     * beyond the `maxLength` characters.
     */
    showExceededText: boolean;
    /**
     * Whether this textarea can grow.
     */
    growing: boolean;
    /**
     * The textarea's value
     */
    set value(value: any);
    get value(): any;
    /** @hidden */
    _textareaCounter?: ElementRef<HTMLDivElement>;
    /** @hidden */
    hasTextExceeded: boolean;
    /** @hidden excess character count */
    exceededCharCount: number;
    /** @hidden a string placeholder that toggles between 'remaining' and 'excess' for the select ICU expression */
    counterExcessOrRemaining: string;
    /** @hidden flag to check if there is an initial value set */
    isValueCustomSet: boolean;
    /** @hidden */
    /** to keep track of number of characters in the textarea */
    private _textAreaCharCount;
    /** @hidden */
    private _isPasted;
    /** for i18n counter message translation */
    private readonly remainingText;
    /** for i18n counter message translation */
    private readonly excessText;
    /**
     * @hidden
     * @see PlatformFormFieldControl.extraContentHeightPx
     */
    get extraContentHeightPx(): number | undefined;
    /** @hidden */
    private get _shouldTrackTextLimit();
    /** @hidden */
    constructor(_textAreaConfig: TextAreaConfig);
    /** when backpress or delete key is pressed when showExceededText field is not set, simply remove excess characters,
     /* else handle autogrow case
     */
    handleBackPress(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngAfterViewChecked(): void;
    /** write value for ControlValueAccessor */
    writeValue(value: any): void;
    /** update the counter message and related interactions */
    updateCounterInteractions(): void;
    /** if exceeded maxlength when set as a value in code, highlight the exceeded text. */
    validateLengthOnCustomSet(): void;
    /** handle exceeded maxlength case when text is pasted */
    handlePasteInteraction(): void;
    /** handle auto growing of textarea */
    autoGrowTextArea(): void;
    /**
     * get line height of textarea
     */
    getTextareaLineHeight(): number;
    /**
     * get the updated state when character count breaches `maxLength`
     */
    getUpdatedState(): FormStates;
    /** @hidden Native element  */
    get _targetElement(): HTMLTextAreaElement;
    /** @hidden get the length of the textarea content */
    private _getContentLength;
    /** @hidden get the total height including borders and scroll height */
    private _getTextareaTotalHeight;
    /** @hidden set initial max height **/
    private _setMaxHeight;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextAreaComponent, "fdp-textarea", never, { "height": { "alias": "height"; "required": false; }; "growingMaxLines": { "alias": "growingMaxLines"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "wrapType": { "alias": "wrapType"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "showExceededText": { "alias": "showExceededText"; "required": false; }; "growing": { "alias": "growing"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformTextAreaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTextAreaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformTextAreaModule, never, [typeof TextAreaComponent], [typeof TextAreaComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformTextAreaModule>;
}

declare class PlatformTimePickerComponent<D> extends BaseInput implements OnInit, AfterViewInit, OnDestroy {
    /**
     * @Input date time object representation
     */
    set value(value: D | null);
    get value(): D | null;
    /**
     * @Input date time object representation
     */
    time: D;
    /** @Input Whether to show spinner buttons */
    spinnerButtons: boolean;
    /** @deprecated
     * Meridian is deprecated. Use displayFormat and parseFormat inputs or
     * DateTimeFormats.display.timeInput and DateTimeFormats.parse.timeInput instead.
     * @Input When set to false, uses the 24 hour clock (hours ranging from 0 to 23).
     * Default value based on the current locale format option
     */
    set meridian(value: boolean);
    get meridian(): boolean;
    /**
     * @Input When set to false, hides the input for seconds.
     * Default value based on the current locale format option
     * */
    displaySeconds: boolean;
    /**
     * @Input When set to false, hides the input for minutes.
     * Default value based on the current locale format option
     * */
    displayMinutes: boolean;
    /**
     * @Input When set to false, hides the input for hours.
     * Default value based on the current locale format option
     * */
    displayHours: boolean;
    /** @Input Default time picker placeholder which is set dependant on the hours, minutes and seconds.
     * Otherwise, It can be set to a default value
     */
    placeholder: string;
    /** Aria label for the time picker input. */
    timePickerInputLabel: string;
    /** Whether a null input is considered valid(success). */
    allowNull: boolean;
    /** Defines if time component should be used with tablet mode */
    tablet: boolean;
    /**
     *  The placement of the popover. It can be one of: top, top-start, top-end, bottom,
     *  bottom-start, bottom-end, right, right-start, right-end, left, left-start, left-end.
     */
    placement: Placement;
    /**
     *  The state of the form control - applies css classes.
     *  Can be `success`, `error`, `warning`, `information` or blank for default.
     */
    set state(state: FormStates | undefined);
    get state(): FormStates;
    /**
     * Whether AddOn Button should be focusable
     * @default true
     */
    buttonFocusable: boolean;
    /** Whether to validate the time picker input. */
    useValidation: boolean;
    /**
     * @Input when set to true, time inputs won't allow to have 1 digit
     * for example 9 will become 09
     * but 12 will be kept as 12.
     */
    keepTwoDigitsTime: boolean;
    /**
     * Display format option to customize time format in input control.
     * Must be a format option that is understandable by DatetimeAdapter.
     */
    displayFormat: unknown;
    /**
     * Parse format option to customize time format in input control.
     * Must be a format option that is understandable by DatetimeAdapter.
     */
    parseFormat: unknown;
    /** Event emitted when the state of the isOpen property changes. */
    readonly isOpenChange: EventEmitter<boolean>;
    /** @hidden */
    timePickerComponent: TimePickerComponent<D>;
    /**
     * The interval between selectable minutes (e.g., 1 for every minute, 5 for 5-minute intervals, 15 for 15-minute intervals).
     * Defaults to 1 (every minute).
     */
    readonly minuteStep: i0.InputSignal<number>;
    /** @hidden */
    private _meridian;
    /** @hidden */
    constructor();
    /**
     * Method that handles changes when popover is opened or closed.
     */
    handleOpenChange(open: boolean): void;
    /**
     * logic to handle validation from both platform forms and core datetiimepicker
     * @param value inputted
     */
    handleTimeChange(value: D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTimePickerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformTimePickerComponent<any>, "fdp-time-picker", never, { "value": { "alias": "value"; "required": false; }; "time": { "alias": "time"; "required": false; }; "spinnerButtons": { "alias": "spinnerButtons"; "required": false; }; "meridian": { "alias": "meridian"; "required": false; }; "displaySeconds": { "alias": "displaySeconds"; "required": false; }; "displayMinutes": { "alias": "displayMinutes"; "required": false; }; "displayHours": { "alias": "displayHours"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "timePickerInputLabel": { "alias": "timePickerInputLabel"; "required": false; }; "allowNull": { "alias": "allowNull"; "required": false; }; "tablet": { "alias": "tablet"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "state": { "alias": "state"; "required": false; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; }; "useValidation": { "alias": "useValidation"; "required": false; }; "keepTwoDigitsTime": { "alias": "keepTwoDigitsTime"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "parseFormat": { "alias": "parseFormat"; "required": false; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; }, { "isOpenChange": "isOpenChange"; }, never, ["*"], true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformTimePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformTimePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformTimePickerModule, never, [typeof PlatformTimePickerComponent], [typeof PlatformTimePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformTimePickerModule>;
}

export { AutoCompleteDirective, BaseCombobox, BaseDynamicFormGeneratorControl, BaseMultiCombobox, BaseMultiInput, BaseSelect, COMBOBOX_COMPONENT, CSS_CLASS_NAME, CheckboxComponent, CheckboxGroupComponent, ComboboxComponent, ComboboxConfig, ComboboxItemDirective, ComboboxItemGroupDirective, ComboboxMobileComponent, ComboboxSecondaryItemDirective, ComboboxSelectedItemDirective, ComboboxSelectionChangeEvent, DEFAULT_COMPONENTS_LIST, DEFAULT_VALIDATION_ERRORS, DefaultGapLayout, DefaultHorizontalFieldLayout, DefaultHorizontalLabelLayout, DefaultVerticalFieldLayout, DefaultVerticalLabelLayout, DynamicFormControl, DynamicFormControlDirective, DynamicFormControlFieldDirective, DynamicFormControlGroup, DynamicFormGeneratorCheckboxComponent, DynamicFormGeneratorDatepickerComponent, DynamicFormGeneratorEditorComponent, DynamicFormGeneratorInputComponent, DynamicFormGeneratorMultiInputComponent, DynamicFormGeneratorObjectStatusComponent, DynamicFormGeneratorRadioComponent, DynamicFormGeneratorSelectComponent, DynamicFormGeneratorSwitchComponent, FDP_COMBOBOX_ITEM_DEF, FDP_FORM_ERROR_DIRECTIVE, FDP_FORM_FIELD_HINT_LAYOUT_CONFIG, FDP_FORM_FIELD_HINT_OPTIONS_DEFAULT, FDP_FORM_GENERATOR_DEFAULT_HINT_OPTIONS, FDP_FORM_IGNORED_STATUSES, FORM_GENERATOR_CONFIG, FORM_GENERATOR_ITEM_CONFIG, FORM_GROUP_CHILD_FIELD_TOKEN, FdpComboboxItemDef, FdpFormGroupModule, FdpSelectionChangeEvent, Field, FieldGroup, FieldGroupRowValuePipe, FormFieldComponent, FormFieldControlExtrasComponent, FormFieldErrorDescriptionDirective, FormFieldErrorDirective, FormFieldErrorHeadingDirective, FormFieldGroupComponent, FormGeneratorComponent, FormGeneratorComponentsAccessorService, FormGeneratorFieldComponent, FormGeneratorService, FormGroupComponent, FormGroupHeaderComponent, GetHintOptionsPipe, INPUT_GROUP_CHILD_TOKEN, InputComponent, InputGroupAddonBodyComponent, InputGroupAddonComponent, InputGroupComponent, InputGroupConfig, InputGroupInputComponent, InputMessageGroupWithTemplate, MAP_LIMIT, MULTICOMBOBOX_COMPONENT, MULTIINPUT_COMPONENT, MultiComboboxComponent, MultiComboboxConfig, MultiComboboxMobileComponent, MultiComboboxSelectionChangeEvent, MultiInputConfig, MultiInputSelectionChangeEvent, NumberStepInputComponent, PlatformAutoCompleteModule, PlatformCheckboxChange, PlatformCheckboxGroupModule, PlatformCheckboxModule, PlatformComboboxMobileModule, PlatformComboboxModule, PlatformDatePickerComponent, PlatformDatePickerModule, PlatformDatetimePickerComponent, PlatformDatetimePickerModule, PlatformFormGeneratorModule, PlatformInputGroupModule, PlatformInputModule, PlatformMultiComboboxMobileModule, PlatformMultiComboboxModule, PlatformMultiInputComponent, PlatformMultiInputMobileComponent, PlatformMultiInputMobileModule, PlatformMultiInputModule, PlatformRadioGroupModule, PlatformSelectModule, PlatformStepInputModule, PlatformSwitchModule, PlatformTextAreaModule, PlatformTimePickerComponent, PlatformTimePickerModule, RadioButtonComponent, RadioGroupComponent, SelectComponent, SelectConfig, StepInputActionButton, StepInputAlign, StepInputChangeEvent, StepInputComponent, StepInputConfig, StepInputControlDirective, StepInputDecrementDirective, StepInputIncrementDirective, SwitchChangeEvent, SwitchComponent, SwitchConfig, TextAreaComponent, TextAreaConfig, addAndCutFloatingNumberDistortion, createMissingDateImplementationError, defaultFormFieldHintOptions, defaultFormGeneratorConfig, defaultFormGeneratorConfigProvider, defaultFormGeneratorHintOptions, defaultFormGeneratorItemConfig, defaultFormGeneratorItemConfigProvider, dynamicFormFieldProvider, dynamicFormGroupChildProvider, formGroupProvider, getField, getFormField, getFormState, getNumberDecimalLength, inputGroupAddonChildProvider, inputGroupInputChildProvider, isFieldChild, isFieldGroupChild, isFieldGroupWrapperChild };
export type { AnyDynamicFormFieldItem, AutoCompleteEvent, BaseDynamicFormFieldGroup, BaseDynamicFormFieldItem, BaseDynamicFormGeneratorControlInterface, BaseDynamicFormItemGuiOptions, CheckboxDynamicFormFieldItem, ComboboxInterface, DatePickerDynamicFormFieldItem, DynamicAbstractControlOptions, DynamicFormFieldGroup, DynamicFormFieldGroupMap, DynamicFormFieldItem, DynamicFormGroup, DynamicFormGroupControl, DynamicFormGroupControls, DynamicFormItem, DynamicFormItemChoice, DynamicFormItemChoiceTypes, DynamicFormItemGuiOptions, DynamicFormItemMap, DynamicFormItemValidationObject, DynamicFormItemValidationResult, DynamicFormValue, FdoComboboxItemDefType, FdpComboBoxDataSource, FdpFormGeneratorAsyncProperty, FdpMultiComboboxDataSource, FdpMultiInputDataSource, FdpSelectData, FieldColumn, FormComponentDefinition, FormGeneratorAcceptableItems, FormGeneratorConfig, FormGeneratorModuleConfig, HintLayoutConfig, InputDynamicFormFieldItem, InputType, MultiComboboxInterface, ObjectStatusDynamicFormFieldItem, PlatformMultiInputInterface, PreparedDynamicFormFieldItem, RadioDynamicFormFieldItem, SelectDynamicFormFieldItem, SelectOptionItem, StepInputStepFunction, StepInputStepFunctionAction, SubmitFormEventResult, SwitchDynamicFormFieldItem, TextAlignment, TextAreaDynamicFormFieldItem, WrapType };