import * as _angular_core from '@angular/core';
import { InputSignalWithTransform, InputSignal, Signal, ModelSignal, OutputEmitterRef, WritableSignal, ElementRef, ChangeDetectorRef, DestroyRef, Injector, InjectionToken, AfterViewInit, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, Subscription, Subject } from 'rxjs';
import * as i2 from '@fundamental-ngx/cdk/data-source';
import { BaseDataSource, AbstractDataProvider, MatchingStrategy, DataProvider, DataSourceDirective, DataSourceParser } from '@fundamental-ngx/cdk/data-source';
import * as i1 from '@fundamental-ngx/cdk/forms';
import { SelectableOptionItem, CvaControl, CvaDirective, FormStates, SelectItem } from '@fundamental-ngx/cdk/forms';
import { ContentDensity, RangeSelector, DynamicComponentService, FocusTrapService, AutoCompleteEvent, FocusEscapeDirection, Nullable } from '@fundamental-ngx/cdk/utils';
import { MobileModeConfig, MobileMode, MobileModeBase } from '@fundamental-ngx/core/mobile-mode';
import { PopoverFillMode } from '@fundamental-ngx/core/shared';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { FormControlComponent } from '@fundamental-ngx/core/form';
import { ListFocusItem } from '@fundamental-ngx/core/list';

declare class FdMultiComboBoxDataSource<T> extends BaseDataSource<T> {
    dataProvider: AbstractDataProvider<T>;
    /** @hidden */
    limitless: boolean;
    /** @hidden */
    constructor(dataProvider: AbstractDataProvider<T>);
}
declare class ArrayMultiComboBoxDataSource<T> extends FdMultiComboBoxDataSource<T> {
    /** @hidden */
    constructor(data: T[]);
}
declare class ObservableMultiComboBoxDataSource<T> extends FdMultiComboBoxDataSource<T> {
    /** @hidden */
    constructor(data: Observable<T[]>);
}
/**
 * Type of acceptable objects as a datasource for the Multi-Combo Box component.
 */
type FdMultiComboboxAcceptableDataSource<T> = FdMultiComboBoxDataSource<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']);
}

/**
 * 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;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiComboboxConfig, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MultiComboboxConfig>;
}

type TextAlignment = 'left' | 'right';
declare abstract class BaseMultiCombobox<T = any> {
    /**
     * Currently selected items in the multi-combobox.
     * To modify selections, use the `writeValue()` or `setValue()` methods.
     */
    abstract selectedItems: T[];
    /**
     * Determines whether items should be grouped in the dropdown.
     * When enabled, items will be organized into groups based on the `groupKey` property.
     */
    abstract group: InputSignalWithTransform<boolean, unknown>;
    /**
     * The property name used to group items when `group` is enabled.
     * This key is used to extract the grouping value from each item object.
     *
     * @example
     * ```typescript
     * // If items are: [{name: 'Apple', category: 'Fruit'}, {name: 'Carrot', category: 'Vegetable'}]
     * groupKey = 'category'; // Groups by 'Fruit' and 'Vegetable'
     * ```
     */
    abstract groupKey: InputSignal<string>;
    /**
     * The property name used to display item labels in the dropdown.
     * For primitive types (strings, numbers), this is ignored and the value itself is displayed.
     * For objects, this specifies which property to use as the display text.
     *
     * @example
     * ```typescript
     * displayKey = 'name'; // Displays item.name for each item
     * ```
     */
    abstract displayKey: InputSignal<string>;
    /**
     * The property name used to display secondary text below the main label.
     * Only displayed when `showSecondaryText` is enabled.
     */
    abstract secondaryKey: InputSignal<string>;
    /**
     * Controls whether secondary text should be displayed for each item.
     * When enabled, uses the `secondaryKey` property to extract and display secondary text.
     */
    abstract showSecondaryText: InputSignalWithTransform<boolean, unknown>;
    /**
     * The property name used as a unique identifier for each item.
     * Used for item comparison, deduplication, and tracking selections.
     * If not specified, the entire object is compared.
     */
    abstract lookupKey: InputSignal<string>;
    /**
     * Signal containing the error message displayed when an invalid entry is detected.
     * Displayed temporarily when the user enters text that doesn't match any available options.
     */
    abstract invalidEntryMessage: InputSignal<string | null | undefined>;
    /**
     * Signal containing the duration (in milliseconds) to display the invalid entry message.
     * After this duration expires, the error message is automatically hidden.
     */
    abstract invalidEntryDisplayTime: Signal<number>;
    /**
     * Model signal controlling whether limitless mode is enabled.
     * In limitless mode, all available items are loaded without pagination limits.
     * Use with caution for large datasets as it may impact performance.
     */
    abstract limitless: ModelSignal<boolean>;
    /**
     * Signal indicating whether the current configuration uses grouped items.
     *
     * @remarks
     * Computed based on whether both `group` and `groupKey` are defined.
     * Used internally to determine rendering strategy.
     */
    abstract isGroup: Signal<boolean>;
    /**
     * Signal containing the current text in the search input field.
     * Updates reactively as the user types. Used for filtering and autocomplete functionality.
     */
    abstract inputText: Signal<string>;
    /**
     * Signal containing a reference to the search input element.
     */
    abstract searchInputElement: Signal<FormControlComponent | undefined>;
    /**
     * Output emitter for selection change events.
     */
    abstract selectionChange: OutputEmitterRef<MultiComboboxSelectionChangeEvent>;
    /**
     * Output emitter for data received events.
     */
    abstract dataReceived: OutputEmitterRef<boolean>;
    /**
     * Output emitter for data request events.
     */
    abstract dataRequested: OutputEmitterRef<boolean>;
    /**
     * Internal writable signal for selected items.
     * Must be implemented by subclass. Provides write access to the selection state.
     * @hidden
     */
    protected abstract _selectedItems: WritableSignal<T[]>;
    /**
     * Internal writable signal for input text.
     * Must be implemented by subclass. Provides write access to the input text.
     *
     * @hidden
     */
    protected abstract _inputText: WritableSignal<string>;
    /**
     * Protected method for internal writes to selectedItems with coercion.
     * Ensures the value is properly coerced to an array before setting.
     *
     * @param value - The new array of selected items
     * @hidden
     */
    protected abstract _setSelectedItems(value: T[]): void;
    /**
     * Protected method for setting input text with side effects.
     * Triggers `onTouched()` callback to mark the control as touched.
     *
     * @param value - The new input text value
     * @hidden
     */
    protected abstract _setInputText(value: string): void;
    /**
     * Control value accessor instance for forms integration.
     * @hidden
     */
    readonly cvaControl: CvaControl<T>;
    /**
     * Data source directive instance for managing async data loading and filtering.
     * @hidden
     */
    readonly dataSourceDirective: DataSourceDirective<T, FdMultiComboBoxDataSource<T>>;
    /** Control Value Accessor directive for forms support. */
    readonly _cva: CvaDirective<any>;
    /** Multi combobox config. */
    readonly _multiComboboxConfig: MultiComboboxConfig | null;
    /** Content Density Observer */
    readonly contentDensityObserver: ContentDensityObserver;
    /**
     * Signal containing currently selected suggestion items.
     * @hidden
     */
    _selectedSuggestions: WritableSignal<SelectableOptionItem<T>[]>;
    /**
     * Signal containing currently matched suggestion items based on search text.
     * Updates when the user types in the search field.
     * Contains filtered options that match the current query.
     * @hidden
     */
    _suggestions: WritableSignal<SelectableOptionItem<any>[]>;
    /**
     * Signal containing flattened suggestion items (groups expanded to flat list).
     * @hidden
     */
    _flatSuggestions: WritableSignal<SelectableOptionItem<any>[]>;
    /**
     * Signal containing the complete flattened list of all available items.
     * @hidden
     */
    _fullFlatSuggestions: WritableSignal<SelectableOptionItem<any>[]>;
    /**
     * Signal indicating whether the "show selected only" mode is active.
     * In mobile mode, toggles between showing all items and showing only selected items.
     * @hidden
     */
    selectedShown: WritableSignal<boolean>;
    /**
     * Writable signal for overriding the invalid entry message with i18n translations.
     * @hidden
     */
    protected readonly _invalidEntryMessageOverride: WritableSignal<string | null>;
    /** @hidden */
    protected readonly _elmRef: ElementRef<any>;
    /** @hidden */
    protected readonly _cd: ChangeDetectorRef;
    /**
     * Maximum number of items to load per page when limitless mode is disabled.
     * Controls pagination size for large datasets.
     * @hidden
     */
    protected readonly _mapLimit: number;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden */
    protected readonly _injector: Injector;
    /** @hidden */
    protected _dataSource: FdMultiComboboxAcceptableDataSource<T>;
    /**
     * Previous input text value before the last change.
     * Used for restoring the input on invalid entry or cancellation.
     * @hidden
     */
    protected _previousInputText: string;
    /**
     * Matching strategy for filtering items based on user input.
     * Determines how items are matched: starts with, contains, etc.
     * Defaults to value from config or `MatchingStrategy.CONTAINS`.
     * @hidden
     */
    protected _matchingStrategy: MatchingStrategy;
    /**
     * Subscription for data source events.
     * @hidden
     */
    protected _dsSubscription: Subscription | null;
    /**
     * Reference to the host element.
     * @hidden
     */
    protected _element: HTMLElement;
    /**
     * @hidden
     * Keys, that won't trigger the popover's open state, when dispatched on search input.
     */
    protected readonly _nonOpeningKeys: number[];
    /**
     * Timer subscription for displaying invalid entry message.
     * Auto-hides the error message after the configured duration.
     * @hidden
     */
    protected _timerSub$: Subscription;
    /**
     * Previous form state before displaying invalid entry error.
     * Stored to restore the original state after error is cleared.
     * @hidden
     */
    protected _previousState?: FormStates;
    /**
     * Previous state message before displaying invalid entry error.
     */
    protected _previousStateMessage: string | null | undefined;
    /**
     * Range selector utility for handling shift+click multi-selection.
     */
    protected readonly _rangeSelector: RangeSelector;
    /**
     * Flag indicating whether the data source has changed.
     * Guard flag: true while waiting for a new data source's first real data emission.
     * Prevents the provider's initial empty emission from being treated as "no results."
     * @hidden
     */
    private _dataSourceChanged;
    /**
     * Signal reference to the popover component.
     * Used for controlling popover visibility and position.
     * @hidden
     */
    private readonly popover;
    /**
     * Writes a value to the control from the forms API.
     *
     * @param value - Array of items to set as selected
     * @remarks
     * Part of the ControlValueAccessor interface. Called by Angular forms
     * when the form model changes.
     * @hidden
     */
    writeValue(value: T[]): 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
     */
    setValue(value: T[], emitOnChange?: boolean): void;
    /** @hidden */
    protected _displayFn: (value: T) => string;
    /** @hidden */
    protected _secondaryFn: (value: T) => string;
    /**
     * @hidden
     * Method to emit change event
     */
    protected _emitChangeEvent(): void;
    /** @hidden */
    protected _setSelectedSuggestions(): void;
    /**
     * Convert original data to SelectableOptionItems Interface
     * @hidden
     */
    protected _convertToOptionItems(items: T[]): SelectableOptionItem<T>[];
    /**
     * Convert data to SelectableOptionItems Interface
     * @hidden
     */
    protected _convertObjectsToOptionItems(items: T[]): SelectableOptionItem<T>[];
    /**
     * Convert object[] data to Group OptionItems Interface
     * @hidden
     */
    protected _convertObjectsToGroupOptionItems<K extends T>(items: K[]): SelectableOptionItem<T>[];
    /**
     * Convert T[] data to Secondary SelectableOptionItems<T> Interface
     * @hidden
     */
    protected _convertObjectsToSecondaryOptionItems<K extends T>(items: K[]): SelectableOptionItem<T>[];
    /**
     * Convert Primitive data(Boolean, String, Number) to SelectableOptionItems Interface
     * @hidden
     */
    protected _convertPrimitiveToOptionItems(items: any[]): SelectableOptionItem<T>[];
    /**
     * Convert T[] to SelectableOptionItems<T> Interface (Default)
     * @hidden
     */
    protected _convertObjectsToDefaultOptionItems(items: T[]): SelectableOptionItem<T>[];
    /** @hidden */
    protected _setInvalidEntry(): void;
    /** @hidden */
    protected _unsetInvalidEntry(): void;
    /** @hidden */
    protected _focusToSearchField(): void;
    /** @hidden */
    protected _mapAndUpdateModel(): void;
    /**
     * @hidden
     * Prepares the data stream and subscribes to it.
     */
    protected _openDataStream(matchingStrategy: MatchingStrategy): void;
    /**
     * Parses the data from the data stream and updates the model if needed.
     * @param data array of objects from the data stream.
     */
    protected _parseDataSourceValue(data: T[]): void;
    /**
     * Transforms plain array into `SelectableOptionItem<T>`
     * @param data
     */
    protected _convertDataSourceSuggestions(data: T[]): void;
    /** @hidden */
    protected _processingEmptyData(): void;
    /**
     * @hidden
     * Configures the data source provider with matching settings.
     */
    private _configureDataSourceProvider;
    /**
     * @hidden
     * Triggers the initial data fetch on the current data source provider.
     */
    private _fetchInitialData;
    /**
     * @hidden
     * Subscribes to dataRequested/dataReceived events from the current data source provider.
     * Unsubscribes from previous provider's events first.
     */
    private _subscribeToDsEvents;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseMultiCombobox<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseMultiCombobox<any>, never, never, {}, {}, never, never, true, never>;
}

declare const FD_MAP_LIMIT: InjectionToken<number>;
declare class MultiComboboxComponent<T = any> extends BaseMultiCombobox<T> implements AfterViewInit, OnInit {
    private readonly _elementRef;
    private readonly _viewContainerRef;
    private readonly _dynamicComponentService;
    private readonly _focusTrapService;
    /**
     * Configuration object for mobile mode appearance and behavior.
     * Only applies when `mobile` is true.
     */
    mobileConfig: MobileModeConfig;
    /**
     * Sets the currently selected items.
     */
    set selectedItems(value: T[] | null | undefined);
    /**
     * Read-only array of currently selected items (backward-compatible API).
     */
    get selectedItems(): T[];
    /**
     * Sets or gets the currently selected value.
     */
    set value(value: T[]);
    /**
     * Gets the current value from the form control.
     * @returns The current array of selected items
     */
    get value(): T[];
    /**
     * Show select all checkbox
     * @defaultValue false
     */
    readonly showSelectAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Maximum height of the dropdown options panel.
     * @defaultValue '250px'
     */
    readonly maxHeight: _angular_core.InputSignal<string>;
    /**
     * Controls whether the addon button can receive keyboard focus.
     * @defaultValue false
     */
    readonly buttonFocusable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     *  Whether the autocomplete should be enabled; Enabled by default.
     * @defaultValue true
     */
    readonly autoComplete: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether list item options should be rendered as byline.
     * @defaultValue false
     */
    readonly byline: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Max width of multi combobox dropdown body.
     * `none` will not limit width of the dropdown.
     * `container` will limit width of the dropdown to the width of the multi-input itself.
     * `number` will limit width of the dropdown by provided number in pixels.
     *
     * @defaultValue 'none'
     */
    readonly bodyMaxWidth: _angular_core.InputSignal<number | "none" | "container">;
    /**
     * Computed maximum width for the popover in pixels.
     * @hidden
     */
    get _popoverMaxWidth(): number | null;
    /**
     * 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
     */
    readonly entityClass: _angular_core.InputSignal<string | undefined>;
    /**
     * Enables mobile-optimized rendering mode.
     * When enabled, displays the combobox in a full-screen dialog optimized for touch devices.
     * Requires `mobileConfig` for full customization.
     *
     * @defaultValue false
     */
    readonly mobile: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Controls whether items should be grouped in the dropdown.
     * When enabled, items are organized by the property specified in `groupKey`.
     * Groups display as headers with items nested underneath.
     *
     * @defaultValue false
     */
    group: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Property path for grouping items.
     * Specifies which property to use for grouping items when `group` is enabled.
     *
     * @example
     * ```typescript
     * groupKey = input('department'); // Groups by item.department
     * ```
     *
     * @defaultValue ''
     */
    groupKey: _angular_core.InputSignal<string>;
    /**
     * Property path for secondary text display.
     * When `showSecondaryText` is enabled, displays this property as secondary text below the main label.
     *
     * @defaultValue ''
     */
    secondaryKey: _angular_core.InputSignal<string>;
    /**
     * Controls visibility of the secondary text column.
     * When enabled, displays secondary text from the `secondaryKey` property in a two-column layout.
     *
     * @defaultValue false
     */
    showSecondaryText: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Horizontally align text inside the second column (applicable for two columns layout).
     *
     * @defaultValue 'right'
     */
    readonly secondaryTextAlignment: _angular_core.InputSignal<"left" | "right">;
    /**
     * Enables automatic width adjustment of the dropdown.
     * When enabled, the dropdown width automatically adjusts based on content.
     * Disable for fixed-width dropdowns.
     *
     * @defaultValue true
     */
    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Controls whether clicking the addon button opens the dropdown.
     * @defaultValue true
     */
    readonly openDropdownOnAddOnClicked: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 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.
     */
    readonly fillControlMode: _angular_core.InputSignal<PopoverFillMode>;
    /** Sets title attribute to addon button. */
    readonly addonIconTitle: _angular_core.InputSignal<string | undefined>;
    /**
     * @deprecated Use the i18n module to modify the translation for this string.
     * Sets invalid entry message.
     * */
    invalidEntryMessage: _angular_core.InputSignal<string | null | undefined>;
    /** Turns limitless mode, ON or OFF */
    limitless: _angular_core.ModelSignal<boolean>;
    /**
     * Used in filters and any kind of comparators when we work with objects and this identify
     * unique field name based on which we are going to do the job
     */
    lookupKey: _angular_core.InputSignal<string>;
    /**
     * When we deal with unknown object we can use `displayKey` to retrieve value from specific
     * property of the object to act as display value.
     *
     * @See ComboBox, Select, RadioGroup, CheckBox Group
     */
    displayKey: _angular_core.InputSignal<string>;
    /**
     * List of values, it can be of type SelectItem, string or any object.
     * Generic object type is among the list of types,
     * because we allow to get labels and values using `displayKey` and `lookupKey` inputs accordingly.
     */
    readonly list: _angular_core.InputSignal<(string | object | SelectItem<any>)[] | undefined>;
    /**
     * Time in ms for how long message of invalid entry should be displayed.
     * @defaultValue 3000
     */
    invalidEntryDisplayTime: _angular_core.InputSignal<number>;
    /**
     * String matching strategy for typeahead list.
     * Available options: 'starts with per term', 'starts with', 'contains'
     * @defaultValue MatchingStrategy.STARTS_WITH_PER_TERM
     */
    readonly matchingStrategy: _angular_core.InputSignal<MatchingStrategy>;
    /** Event emitted when item is selected. */
    selectionChange: _angular_core.OutputEmitterRef<MultiComboboxSelectionChangeEvent>;
    /** @hidden Emits event when the menu is opened/closed. */
    isOpenChange: _angular_core.OutputEmitterRef<boolean>;
    /** Emits event when the addon button is clicked. */
    addOnButtonClicked: _angular_core.OutputEmitterRef<Event>;
    /** Event emitted when data loading is started. */
    dataRequested: _angular_core.OutputEmitterRef<boolean>;
    /** Event emitted when data loading is finished. */
    dataReceived: _angular_core.OutputEmitterRef<boolean>;
    /**
     * References the search input element within the template.
     * @hidden
     */
    readonly searchInputElement: _angular_core.Signal<FormControlComponent | undefined>;
    /**
     * @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>;
    /**
     * Observable version of selectionChange for template use.
     *
     * @remarks
     * Used internally for components that require an Observable instead of OutputEmitterRef until we migrate everything to signals
     * Converts the output signal to an RxJS Observable.
     *
     * @hidden
     */
    readonly selectionChange$: rxjs.Observable<MultiComboboxSelectionChangeEvent>;
    /**
     * Content density mode for the component.
     * @hidden
     */
    _contentDensity: ContentDensity;
    /**
     * Computed signal for the current input text value.
     * @returns Computed signal containing the current input text
     */
    inputText: _angular_core.Signal<string>;
    /**
     * Indicates whether the search field is empty.
     * @returns true if the search field is empty, false otherwise
     */
    get isEmptyValue(): boolean;
    /**
     * Computed signal indicating whether grouping is active.
     * @hidden
     */
    isGroup: _angular_core.Signal<boolean>;
    /**
     * Tracks whether the dropdown is currently open.
     */
    isOpen: boolean;
    /**
     * @hidden
     * Max width of list container
     */
    maxWidth: number;
    /**
     * @hidden
     * Min width of list container
     */
    minWidth: number;
    /**
     * @hidden
     * Subject for communicating dropdown open/close state to mobile mode component.
     */
    openChange: Subject<boolean>;
    /**
     * Internal writable signal storing the array of selected items.
     *
     * @remarks
     * Provides the underlying storage for the `selectedItems` property.
     * Modified through `_setSelectedItems()` to ensure proper coercion.
     *
     * @hidden Internal writable signal for selected items
     */
    protected readonly _selectedItems: _angular_core.WritableSignal<T[]>;
    /**
     * Internal writable signal storing the current input text.
     *
     * @remarks
     * Provides the underlying storage for the `inputText` computed signal.
     * Modified through `_setInputText()` to ensure side effects (like `onTouched`) are triggered.
     *
     * @hidden Internal writable signal for input text
     */
    protected readonly _inputText: _angular_core.WritableSignal<string>;
    /**
     * Reference to the list component instance.
     * @hidden
     */
    private readonly listComponent;
    /**
     * Collection of custom templates provided by content projection.
     * @hidden
     */
    private readonly customTemplates;
    /**
     * Template reference for the mobile mode control.
     * @hidden
     */
    private readonly mobileControlTemplate;
    /**
     * Template reference for the dropdown list.
     * @hidden
     */
    private readonly listTemplate;
    /**
     * Reference to the tokenizer component instance.
     * @hidden
     */
    private readonly _tokenizer;
    /**
     * Reference to the input group element.
     * @hidden
     */
    private readonly _inputGroup;
    /**
     * @hidden
     */
    private readonly items;
    /**
     * Observable stream of the current language configuration.
     * @hidden
     */
    private readonly _langSignal;
    /**
     * Helper for resolving translation keys to localized strings.
     * @hidden
     */
    private _translationResolver;
    /** @hidden */
    constructor(_elementRef: ElementRef, _viewContainerRef: ViewContainerRef, _dynamicComponentService: DynamicComponentService, _focusTrapService: FocusTrapService);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): Promise<void>;
    /** @hidden */
    _toggleSelection(item: SelectableOptionItem, fromTokenCloseClick?: boolean): void;
    /** @hidden */
    _onOptionCheckboxClicked(event: MouseEvent, index: number): void;
    /** @hidden */
    _onCompleteTerm(event: AutoCompleteEvent): 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 */
    _onItemKeyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    _onOptionClicked(event: MouseEvent, index: number): 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 */
    _popoverOpenChangeHandle(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;
    /**
     * @hidden
     * Method passed to list component.
     */
    _handleListFocusEscape(direction: FocusEscapeDirection): void;
    /**
     * @hidden
     */
    _addOnClicked($event: Event): void;
    /** @hidden */
    _setLimitless(limitless: boolean): void;
    /** @hidden */
    _getMapLimit(): number;
    /** @hidden */
    _getGroupItemIds(groupIndex: number): string;
    /**
     * Updates the selected items with proper array coercion.
     *
     * @param value - The new array of selected items
     *
     * @remarks
     * Ensures the value is always a valid array, even if null or undefined is provided.
     * Use this method instead of directly setting `_selectedItems`.
     *
     * @hidden Protected method for internal writes with coercion
     */
    protected _setSelectedItems(value: T[]): void;
    /**
     * Updates the input text and triggers form control touch event.
     *
     * @param value - The new input text value
     *
     * @remarks
     * Sets the input text and calls `onTouched()` to mark the form control as touched.
     * Ensures proper integration with Angular forms and validation.
     *
     * @hidden Protected method for setting input text with side effects
     */
    protected _setInputText(value: string): void;
    /**
     * @hidden
     * Recursively update selection state for items and their children (for grouped suggestions)
     */
    private _updateSelectionRecursive;
    /** @hidden */
    private _toggleSelectionByInputText;
    /**
     * @hidden
     * Method to set input text as item label.
     */
    private _setInputTextFromOptionItem;
    /**
     * @hidden
     * applying range selection. Note, that this function will be invoked after combobox item's value has been changed
     */
    private _onListElementClicked;
    /** @hidden */
    private _propagateChange;
    /** @hidden */
    private _setUpMobileMode;
    /**
     * @hidden
     * Method that picks other value moved from current one by offset, called only when Multi Combobox is closed.
     */
    private _chooseOtherItem;
    /** @hidden */
    private _initWindowResize;
    /** @hidden */
    private _getOptionsListWidth;
    /**
     * @hidden
     * Assign custom templates
     */
    private _assignCustomTemplates;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiComboboxComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiComboboxComponent<any>, "fd-multi-combobox", never, { "mobileConfig": { "alias": "mobileConfig"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; "value": { "alias": "value"; "required": false; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "buttonFocusable": { "alias": "buttonFocusable"; "required": false; "isSignal": true; }; "autoComplete": { "alias": "autoComplete"; "required": false; "isSignal": true; }; "byline": { "alias": "byline"; "required": false; "isSignal": true; }; "bodyMaxWidth": { "alias": "bodyMaxWidth"; "required": false; "isSignal": true; }; "entityClass": { "alias": "entityClass"; "required": false; "isSignal": true; }; "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "group": { "alias": "group"; "required": false; "isSignal": true; }; "groupKey": { "alias": "groupKey"; "required": false; "isSignal": true; }; "secondaryKey": { "alias": "secondaryKey"; "required": false; "isSignal": true; }; "showSecondaryText": { "alias": "showSecondaryText"; "required": false; "isSignal": true; }; "secondaryTextAlignment": { "alias": "secondaryTextAlignment"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "openDropdownOnAddOnClicked": { "alias": "openDropdownOnAddOnClicked"; "required": false; "isSignal": true; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; "isSignal": true; }; "addonIconTitle": { "alias": "addonIconTitle"; "required": false; "isSignal": true; }; "invalidEntryMessage": { "alias": "invalidEntryMessage"; "required": false; "isSignal": true; }; "limitless": { "alias": "limitless"; "required": false; "isSignal": true; }; "lookupKey": { "alias": "lookupKey"; "required": false; "isSignal": true; }; "displayKey": { "alias": "displayKey"; "required": false; "isSignal": true; }; "list": { "alias": "list"; "required": false; "isSignal": true; }; "invalidEntryDisplayTime": { "alias": "invalidEntryDisplayTime"; "required": false; "isSignal": true; }; "matchingStrategy": { "alias": "matchingStrategy"; "required": false; "isSignal": true; }; }, { "limitless": "limitlessChange"; "selectionChange": "selectionChange"; "isOpenChange": "isOpenChange"; "addOnButtonClicked": "addOnButtonClicked"; "dataRequested": "dataRequested"; "dataReceived": "dataReceived"; }, ["customTemplates"], ["*", "*"], true, [{ directive: typeof i1.CvaDirective; inputs: { "id": "inputId"; "placeholder": "placeholder"; "state": "state"; "stateMessage": "stateMessage"; "disabled": "disabled"; "readonly": "readonly"; "name": "name"; }; outputs: {}; }, { directive: typeof i2.DataSourceDirective; inputs: { "dataSource": "dataSource"; }; outputs: { "dataChanged": "dataChanged"; }; }]>;
}

declare class SelectAllTogglerComponent extends ListFocusItem implements OnInit {
    /**
     * Handler for the select all items
     * */
    selectAllHandler: (select: boolean) => void;
    /**
     * Stream for receiving information about the value changes,
     */
    valueChanges: Observable<unknown>;
    /** @hidden */
    selectedItems: Array<unknown>;
    /** @hidden */
    flatItems: Array<unknown>;
    /** @hidden */
    get allAreSelected(): boolean;
    /** @hidden */
    get someAreSelected(): boolean;
    /** @hidden */
    get checkboxValue(): boolean | null;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private changeDetector;
    /** @hidden */
    onKeyDown($event: Event): void;
    /** @hidden */
    onClick(): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    change(value: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectAllTogglerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectAllTogglerComponent, "fd-multi-combobox-select-all-toggler", never, { "selectAllHandler": { "alias": "selectAllHandler"; "required": false; }; "valueChanges": { "alias": "valueChanges"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; "flatItems": { "alias": "flatItems"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MultiAnnouncerDirective {
    /** @hidden */
    multiAnnouncerOptions: unknown[];
    /** @hidden */
    private _tokens;
    /** @hidden */
    private _noResultsAnnounced;
    /** @hidden */
    private _resultsAnnounced;
    /** @hidden */
    private _announcement;
    /** @hidden */
    private readonly _liveAnnouncer;
    /** @hidden */
    private _resolveTranslation;
    /** @hidden */
    protected _makeSearchTermChangeAnnouncements(event: KeyboardEvent): void;
    /** @hidden */
    private _buildAnnouncement;
    /** @hidden */
    private _makeAnnouncement;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiAnnouncerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MultiAnnouncerDirective, "[fdMultiAnnouncer]", ["fdMultiAnnouncer"], { "multiAnnouncerOptions": { "alias": "multiAnnouncerOptions"; "required": false; }; }, {}, ["_tokens"], never, true, never>;
}

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

declare class MultiComboboxDataSourceParser<T> implements DataSourceParser<T, FdMultiComboBoxDataSource<T>> {
    /**
     * Transforms plain array or observable into DataSource class.
     * @param source
     */
    parse(source: FdMultiComboboxAcceptableDataSource<T>): FdMultiComboBoxDataSource<T> | undefined;
}

/** @hidden */
declare function lookupValue(item: unknown, lookupKey: string): string;
/** @hidden */
declare function displayValue(item: unknown, displayKey: string): string;
/** @hidden */
declare function objectGet(obj: unknown, is: string | string[] | undefined): any;
/** @hidden */
declare function getSelectItemByInputValue<T>(suggestions: SelectableOptionItem<T>[], needleValue: string): SelectableOptionItem<T> | undefined;
/** @hidden
 *  Map grouped values to array. */
declare function flattenGroups(items: SelectableOptionItem[]): SelectableOptionItem[];
/** @hidden */
declare function getTokenIndexByIdlOrValue(item: SelectableOptionItem, suggestions: SelectableOptionItem[]): number;

interface MultiCombobox<T = any> {
    selectedItems: T[];
    displayKey: InputSignal<string>;
    lookupKey: InputSignal<string>;
    showSecondaryText: InputSignal<boolean>;
    secondaryKey: InputSignal<string>;
    groupKey: InputSignal<string>;
    isGroup: Signal<boolean>;
    _suggestions: Signal<SelectableOptionItem[]>;
    _selectedSuggestions: Signal<SelectableOptionItem<T>[]>;
}
/**
 * Combobox Interface to have typing and avoid circular dependency between
 * MultiComboboxComponent <==> MultiComboboxMobileComponent
 */
interface MobileMultiComboboxInterface extends MobileMode, MultiCombobox {
    selectedShown: WritableSignal<boolean>;
    openChange: Subject<boolean>;
    _moreClicked(): void;
    _dialogApprove(): void;
    _dialogDismiss(backup: SelectableOptionItem[]): void;
    _searchTermChanged(term?: string): void;
}

declare class MobileMultiComboboxComponent extends MobileModeBase<MobileMultiComboboxInterface> 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: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    private _selectedBackup;
    /** @hidden */
    constructor(multiComboboxComponent: MobileMultiComboboxInterface);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    showSelected(): void;
    /** @hidden */
    handleDismiss(): void;
    /** @hidden */
    handleApprove(): void;
    /** @hidden */
    private _toggleDialog;
    /** @hidden */
    private _listenOnMultiComboboxOpenChange;
    /** @hidden */
    private _open;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobileMultiComboboxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobileMultiComboboxComponent, "fd-mobile-multi-combobox", never, {}, {}, never, never, true, never>;
}

declare const MULTI_COMBOBOX_COMPONENT: InjectionToken<unknown>;

export { ArrayMultiComboBoxDataSource, BaseMultiCombobox, FD_MAP_LIMIT, FdMultiComboBoxDataSource, MULTI_COMBOBOX_COMPONENT, MobileMultiComboboxComponent, MultiAnnouncerDirective, MultiComboboxComponent, MultiComboboxConfig, MultiComboboxDataSourceParser, MultiComboboxModule, MultiComboboxSelectionChangeEvent, ObservableMultiComboBoxDataSource, SelectAllTogglerComponent, displayValue, flattenGroups, getSelectItemByInputValue, getTokenIndexByIdlOrValue, lookupValue, objectGet };
export type { FdMultiComboboxAcceptableDataSource, MobileMultiComboboxInterface, MultiCombobox, TextAlignment };
