import * as i0 from '@angular/core';
import { TemplateRef, OnDestroy, AfterViewChecked, EventEmitter, ChangeDetectorRef, ElementRef, OnInit, AfterViewInit, AfterContentInit, DoCheck, QueryList, NgZone, InjectionToken } from '@angular/core';
import * as i5 from '@angular/cdk/a11y';
import { Highlightable, LiveAnnouncer, ListKeyManagerOption, ActiveDescendantKeyManager, FocusOrigin } from '@angular/cdk/a11y';
import { Direction, Directionality } from '@angular/cdk/bidi';
import { BooleanInput } from '@angular/cdk/coercion';
import * as i4 from '@angular/cdk/overlay';
import { ConnectionPositionPair, CdkOverlayOrigin, CdkConnectedOverlay, ScrollStrategy, Overlay } from '@angular/cdk/overlay';
import * as i8 from '@angular/forms';
import { ControlValueAccessor, NgControl, NgForm, FormGroupDirective } from '@angular/forms';
import * as i2 from '@aposin/ng-aquila/formfield';
import { NxFormfieldControl, NxFormfieldComponent, AppearanceType } from '@aposin/ng-aquila/formfield';
import { NxAbstractControl } from '@aposin/ng-aquila/shared';
import { ErrorStateMatcher } from '@aposin/ng-aquila/utils';
import { Subject, Observable } from 'rxjs';
import * as i1 from '@angular/common';
import * as i3 from '@aposin/ng-aquila/checkbox';
import * as i6 from '@aposin/ng-aquila/icon';
import * as i7 from '@angular/cdk/observers';
import * as i9 from '@aposin/ng-aquila/tooltip';
import * as i10 from '@aposin/ng-aquila/button';
import * as i11 from '@aposin/ng-aquila/input';

declare class NxDropdownClosedLabelDirective {
    readonly templateRef: TemplateRef<any>;
    constructor(templateRef: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NxDropdownClosedLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NxDropdownClosedLabelDirective, "[nxClosedLabel]", never, {}, {}, never, never, true, never>;
}

declare abstract class NxDropdownControl extends NxFormfieldControl<any> {
    /**
     * Whether the dropdown should allow multi selection and additional checkboxes are shown.
     *
     * Note: Please make sure the value you bind is an array. If not an error is thrown!
     */
    isMultiSelect: boolean;
    ignoreItemTruncation: boolean;
    readonly filterChanges: Subject<any>;
    readonly _closedStream: Observable<void>;
    abstract filterFn(search: string, itemValue: string): boolean;
    abstract valueFormatter(value: any): string;
    /** @docs-private */
    abstract formatValue?(value: any): string;
}

declare class NxDropdownGroupComponent {
    private static nextId;
    id: string;
    /** Label displayed in the group. */
    label: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxDropdownGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxDropdownGroupComponent, "nx-dropdown-group", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class NxDropdownItemChange {
    /** Reference to the option that emitted the event. */
    readonly item: NxDropdownItemComponent;
    /** Whether the change in the option's value was a result of a user action. */
    readonly isUserInput: boolean;
    constructor(
    /** Reference to the option that emitted the event. */
    item: NxDropdownItemComponent, 
    /** Whether the change in the option's value was a result of a user action. */
    isUserInput?: boolean);
}
declare class NxDropdownItemComponent implements Highlightable, OnDestroy, AfterViewChecked {
    private readonly _dropdown;
    /** @docs-private */ readonly group: NxDropdownGroupComponent | null;
    private readonly _cdr;
    private readonly _elementRef;
    _hidden: boolean;
    private _mostRecentViewValue;
    private readonly _id;
    /**
     * The value of the dropdown item.
     * You can't use undefined, null and '' (empty strings)
     * as they are sentinel values signalling empty data.
     */
    value: any;
    get label(): string;
    /** The unique ID of the option. */
    get id(): string;
    private _disabled;
    /** Whether the dropdown item is disabled. */
    set disabled(value: BooleanInput);
    get disabled(): boolean;
    private _selected;
    /** Whether the item is selected. */
    get selected(): boolean;
    private _active;
    /** Whether the item is active. */
    get active(): boolean;
    /**
     * Whether the parent dropdown is in multiselect mode.
     * @docs-private
     */
    get multiselect(): boolean;
    /** Emits whenever the component is destroyed. */
    private readonly _destroyed;
    /** Event emitted when the option is selected or deselected. */
    readonly onSelectionChange: EventEmitter<NxDropdownItemChange>;
    /** Emits when the state of the option changes and any parents have to be notified. */
    readonly _stateChanges: Subject<void>;
    /**
     * The wrapping div in the template. Used by dropdown to use the container height for scrolling.
     * @docs-private
     */
    containerElement: any;
    constructor(_dropdown: NxDropdownControl, 
    /** @docs-private */ group: NxDropdownGroupComponent | null, _cdr: ChangeDetectorRef, _elementRef: ElementRef);
    ngAfterViewChecked(): void;
    private _updateViewValue;
    ngOnDestroy(): void;
    _onClick(event: Event): void;
    /**
     * Selects the option while indicating the selection came from the user. Used to
     * determine if the select's view -> model callback should be invoked.
     */
    _selectViaInteraction(): void;
    /**
     * Gets the `aria-selected` value for the option. The attribute is omitted from the single-select dropdown
     * for the unselected options. Including the `aria-selected="false" attributes adds a lot of of noise to
     * screen-reader users without providing useful information.
     * @docs-private
     */
    _getAriaSelected(): boolean | null;
    /** @docs-private */
    show(): void;
    /** @docs-private */
    hide(): void;
    private _showOrHideByFilter;
    get _formattedValue(): string;
    /** @docs-private */
    get viewValue(): any;
    /** @docs-private */
    get elementRef(): ElementRef<any>;
    select(): void;
    /** @docs-private */
    deselect(): void;
    _initSelected(selected: boolean): void;
    /** @docs-private */
    focus(): void;
    private _emitSelectionChangeEvent;
    /** @docs-private */
    setActiveStyles(): void;
    /** @docs-private */
    setInactiveStyles(): void;
    /**
     * Returns the list item's text label. Implemented as a part of the ListKeyManagerOption.
     * @docs-private
     */
    getLabel(): string;
    _isContentEmpty(element: Element): boolean;
    _onLabelChange(): void;
    /** Returns the correct tabindex for the option depending on disabled state. */
    _getTabIndex(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxDropdownItemComponent, [null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxDropdownItemComponent, "nx-dropdown-item", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["*"], true, never>;
}

/**
 * An option of the dropdown.
 * Contains a value and an optional label.
 * If no label is specified, the value will be displayed instead.
 */
interface NxDropdownOption {
    value: any;
    label?: string;
}
type NxDropdownPanelMinWidth = 'trigger' | 'none';
/** Vertical alignment of dropdown checkmark */
type VerticalAlignCheckmark = 'top' | 'center';
/** Dropdown data that requires internationalization. */
declare class NxDropdownIntl {
    /**
     * Stream that emits whenever the labels here are changed. Use this to notify
     * components if the labels have changed after initialization.
     */
    readonly changes: Subject<void>;
    /** A label for the multi-select component. */
    selectAll: string;
    /**
     * A label for the multi-select component.
     * @deprecated No longer used.
     * @deletion-target 18.0.0
     */
    clearAll: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxDropdownIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NxDropdownIntl>;
}
/** Change event object that is emitted when the select value has changed. */
declare class NxDropdownSelectChange<T = any> {
    /** Reference to the select that emitted the change event. */
    readonly source: NxDropdownComponent;
    /** Current value of the select that emitted the event. */
    readonly value: T;
    constructor(
    /** Reference to the select that emitted the change event. */
    source: NxDropdownComponent, 
    /** Current value of the select that emitted the event. */
    value: T);
}
/** Injection token that determines the scroll handling while a dropdown is open. */
declare const NX_DROPDOWN_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
/**
 * @docs-private
 * @deprecated No longer used.
 * @deletion-target 18.0.0
 */
declare function NX_DROPDOWN_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => ScrollStrategy;
/**
 * @docs-private
 * @deprecated No longer used.
 * @deletion-target 18.0.0
 */
declare const NX_DROPDOWN_SCROLL_STRATEGY_PROVIDER: {
    provide: InjectionToken<() => ScrollStrategy>;
    useFactory: typeof NX_DROPDOWN_SCROLL_STRATEGY_PROVIDER_FACTORY;
    deps: (typeof Overlay)[];
};
type FilterInputType = 'text' | 'number' | 'tel' | 'search' | 'date' | 'datetime' | 'month' | 'email';
type NxDropdownFilterFn = (query: string, label: string) => boolean;
type NxDropdownCompareWithFn = (o1: any, o2: any) => boolean;
type NxDropdownValueFormatterFn = (value: any) => any;
declare class NxDropdownComponent implements NxAbstractControl, NxDropdownControl, ControlValueAccessor, OnInit, AfterViewInit, AfterContentInit, OnDestroy, DoCheck {
    #private;
    private readonly _cdr;
    private readonly _elementRef;
    private readonly _ngZone;
    private readonly formFieldComponent;
    private readonly _errorStateMatcher;
    /** @docs-private */ readonly ngControl: NgControl | null;
    private readonly _parentForm;
    private readonly _parentFormGroup;
    private readonly _dir;
    private readonly _defaultScrollStrategyFactory;
    private readonly liveAnnouncer;
    /** Whether the dropdown is readonly. */
    set readonly(value: BooleanInput);
    get readonly(): boolean;
    private _readonly;
    /** set readonly state */
    setReadonly(value: boolean): void;
    ariaLabelledBy: string | null;
    verticalAlignCheckmark: VerticalAlignCheckmark;
    private _selectionModel;
    /** The ID of rendered dropdown html element. */
    readonly renderedValueId: string;
    readonly modalId: string;
    private _focused;
    /** Whether or not the overlay panel is open. */
    private _panelOpen;
    /** @docs-private */
    errorState: boolean;
    _tooltipText: string;
    /** Width of the overlay panel. */
    _overlayWidth: string | number;
    /** Min-width of the overlay panel. */
    _overlayMinWidth: string | number;
    /**
     * Name of this control that is used inside the formfield component.
     * @docs-private
     */
    controlType: string;
    /** The minimal space between the viewport and the overlay */
    _overlayViewportMargin: number;
    /** Holds the panelWidth after panel was attached. */
    _panelWidth?: number;
    _positions: ConnectionPositionPair[];
    /**
     * Emits when internal state changes to inform formfield about it.
     * @docs-private
     */
    readonly stateChanges: Subject<void>;
    /** @docs-private */
    ariaDescribedby?: string;
    /**
     * Array of options for the dropdown.
     */
    set options(value: NxDropdownOption[]);
    get options(): NxDropdownOption[];
    private readonly _options;
    /**
     * Type of filter input (default: text).
     */
    set filterInputType(value: FilterInputType);
    get filterInputType(): FilterInputType;
    private _filterInputType;
    set tabIndex(value: number);
    get tabIndex(): number;
    private _tabIndex;
    /** Selected value */
    set value(newValue: any);
    get value(): any;
    /** Holds the value from nxValue. */
    private _value;
    /** Whether the dropdown is disabled. */
    set disabled(value: BooleanInput);
    get disabled(): boolean;
    protected _disabled: boolean;
    /**
     * Whether the dropdown should allow multi selection and additional checkboxes are shown.
     * Note: Please make sure the value you bind is an array.
     * @throws Error if true and the bound value is not an array.
     * @deprecated Please use the new `<nx-multi-select>` component instead.
     */
    isMultiSelect: boolean;
    /** The id of the input. */
    get id(): string;
    /** Whether the component is required. This adds an aria-required label to the component. */
    set required(value: BooleanInput);
    get required(): boolean;
    protected _required: boolean;
    private _style;
    /** Whether the dropdown should render in its negative style or not. */
    _negative: boolean;
    /** If set to 'negative', the component is displayed with the negative set of styles. */
    set styles(value: string);
    /** Placeholder to be shown if no value has been selected. */
    set placeholder(value: string);
    get placeholder(): string;
    private _placeholder;
    /**
     * Disable truncation of long item texts.
     * We recommend following UX guidelines and always truncating long items.
     * Please only disable truncation if it's impossible to use short descriptions.
     * @deprecated
     */
    set ignoreItemTruncation(value: BooleanInput);
    get ignoreItemTruncation(): boolean;
    private _ignoreItemTruncation;
    /** Whether the dropdown should be shown with an additional filter input. */
    showFilter: boolean;
    /** Text displayed as placeholder for the filter. */
    filterPlaceholder: string;
    /** Text that is displayed at the top of the overlay. If not set the formfield label is used by default. */
    overlayLabel: string;
    /** Can be used as a fallback to the CdkOverlayOrigin */
    overlayFallbackOrigin: NxDropdownComponent;
    panelMaxWidth: string | number;
    /** Event emitted when the select panel has been toggled. */
    readonly openedChange: EventEmitter<boolean>;
    /** Event emitted when the select panel has been focus out. */
    readonly focusOut: EventEmitter<boolean>;
    /** Event emitted when the dropdown items get filtered. Returns the currently visible dropdown items. */
    readonly filterResultChange: EventEmitter<NxDropdownItemComponent[]>;
    /** Event emitted when the select has been opened. */
    readonly _openedStream: Observable<void>;
    /** Event emitted when the select has been closed. */
    readonly _closedStream: Observable<void>;
    /** Event emitted when the user types in the filter input. */
    readonly filterChanges: EventEmitter<any>;
    /**
     * Event that emits whenever the raw value of the select changes. This is here primarily
     * to facilitate the two-way binding for the `value` input.
     * @docs-private
     */
    readonly valueChange: EventEmitter<any>;
    /** Event emitted when the selected value has been changed. */
    readonly selectionChange: EventEmitter<NxDropdownSelectChange<any>>;
    /**
     * Panel containing the select options.
     * @docs-private
     */
    panel?: ElementRef;
    /** @docs-private */
    panelBody?: ElementRef;
    /** @docs-private */
    trigger: ElementRef;
    /** @docs-private */
    fallbackOrigin: ElementRef | CdkOverlayOrigin;
    /** @docs-private */
    filterInput?: ElementRef;
    /** @docs-private */
    filterValue: string;
    /**
     * Overlay pane containing the options.
     * @docs-private
     */
    overlayDir: CdkConnectedOverlay;
    _contentDropdownItems: QueryList<NxDropdownItemComponent>;
    /** @docs-private */
    groups: any;
    _customClosedDropdownLabel: NxDropdownClosedLabelDirective;
    private _defaultClosedDropdownLabel;
    _lazyDropdownItems: QueryList<NxDropdownItemComponent>;
    get dropdownItems(): QueryList<NxDropdownItemComponent>;
    /** @docs-private */
    get closedDropdownLabel(): TemplateRef<any>;
    private _closedDropdownLabel;
    private readonly _destroyed;
    private _keyManager;
    private panelMinWidthWasSet;
    private panelGrowWasSet;
    private ignoreItemTruncationWasSet;
    set panelOpen(value: boolean);
    /** @docs-private */
    get panelOpen(): boolean;
    /** Strategy factory that will be used to handle scrolling while the dropdown panel is open. */
    private readonly _scrollStrategyFactory;
    /** Strategy that will be used to handle scrolling while the dropdown panel is open. */
    _scrollStrategy: ScrollStrategy;
    /** @docs-private */
    get label(): string;
    /**
     * Sets how the panel min width will be determined.
     * 'trigger' will set the panels min-width to the trigger width.
     * 'none' will not set a min-width and will let the panel grow naturally with its content so it can be smaller than the trigger.
     * This is mostly for special use cases like the country code dropdown in the phone input.
     * @deprecated Use `panelGrow` instead.
     */
    set panelMinWidth(value: NxDropdownPanelMinWidth);
    get panelMinWidth(): NxDropdownPanelMinWidth;
    _panelMinWidth: NxDropdownPanelMinWidth;
    /**
     * panelGrow: true means the overlay can grow larger than the trigger and grows with the longest label
     * panelGrow: false means the overlay is the size of the trigger
     */
    set panelGrow(value: boolean);
    get panelGrow(): boolean;
    _panelGrow: boolean;
    /**
     * Function that transforms the value into a string.
     * This function is used for displaying and filtering the content.
     *
     * Default: `(value: any) => value == null ? '' : value.toString()`.
     */
    set valueFormatter(value: NxDropdownValueFormatterFn | null | undefined);
    get valueFormatter(): NxDropdownValueFormatterFn;
    /**
     * Function to compare the option values with the selected values. The first argument
     * is a value from an option. The second is a value from the selection. A boolean
     * should be returned.
     *
     * Defaults to object equality.
     */
    set compareWith(value: NxDropdownCompareWithFn | null | undefined);
    get compareWith(): NxDropdownCompareWithFn;
    /**
     * Function to be used when the user types into the search filter. The first argument is the user input,
     * the second argument is the dropdown item value as displayed. The dropdown items will use this function
     * to set their visibility state. A boolean should be returned.
     *
     * Defaults to lower case inclusion.
     */
    set filterFn(value: NxDropdownFilterFn | null | undefined);
    get filterFn(): NxDropdownFilterFn;
    /**
     * Whether the select is focused.
     * @docs-private
     */
    get focused(): boolean;
    /** `View -> model callback called when value changes` */
    _onChange: (value: any) => void;
    /** `View -> model callback called when select has been touched` */
    _onTouched: () => void;
    /** @docs-private */
    get elementRef(): ElementRef;
    /** The text direction of the containing app. */
    get dir(): Direction;
    activeId: i0.WritableSignal<string | null>;
    constructor(_cdr: ChangeDetectorRef, _elementRef: ElementRef, _ngZone: NgZone, tabIndex: string, formFieldComponent: NxFormfieldComponent | null, _errorStateMatcher: ErrorStateMatcher, 
    /** @docs-private */ ngControl: NgControl | null, _parentForm: NgForm | null, _parentFormGroup: FormGroupDirective | null, _dir: Directionality | null, _defaultScrollStrategyFactory: () => ScrollStrategy, liveAnnouncer: LiveAnnouncer);
    ngDoCheck(): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    /** @docs-private */
    updateErrorState(): void;
    private _updateTooltipText;
    /** Sets up a key manager to listen to keyboard events on the overlay panel. */
    private _initKeyManager;
    openedByKeyboard: boolean;
    private _initActiveItem;
    private _subscribeToOptionChanges;
    /** Invoked when an option is clicked. */
    _onSelect(option: NxDropdownItemComponent, isUserInput: boolean, item?: NxDropdownOption): void;
    private _initializeSelection;
    /**
     * Sets the selected option based on a value. If no option can be
     * found with the designated value, the select trigger is cleared.
     */
    private _setSelectionByValue;
    /**
     * Finds and selects and option based on its value.
     */
    private _selectValue;
    /** Emits change event to set the model value. */
    private _propagateChanges;
    /** Sorts the selected values in the selected based on their order in the panel. */
    private _sortValues;
    /** Adds a offset to the overlay position, so the formfield label and the dropdown panel header are vertically aligned. */
    private _updatePosition;
    /** Focuses the select element. */
    focus(): void;
    get overlayOrigin(): ElementRef<any> | CdkOverlayOrigin;
    /** Opens the panel of the dropdown. */
    openPanel($event: Event): void;
    private getOverlayWidth;
    /** Closes the panel of the dropdown. */
    closePanel(): void;
    private _scrollActiveOptionIntoCenter;
    /** Scrolls the active option into view. */
    private _scrollActiveOptionIntoView;
    private _getItemOffset;
    /**
     * Formfield implementation.
     * @docs-private
     */
    setDescribedByIds(ids: string[]): void;
    /**
     * Support for aria-label removed in favor of aria-labelledby
     * The NxFormfieldControl abstract class requires implementation
     * of below method.
     * @docs-private
     */
    setAriaLabel(value: string): string;
    /**
     * Returns html ids of dropdown rendered value and label (if available),
     * separated by space.
     * @docs-private
     */
    _getAriaLabelledBy(): string;
    get _isInOutlineField(): boolean;
    /**
     * Whether the select has a value.
     * @docs-private
     */
    get empty(): boolean;
    /** @docs-private */
    get hasValue(): boolean;
    /** @docs-private */
    get shouldLabelFloat(): boolean;
    /** End Formfield */
    /** ControlValueAccessor */
    /**
     * Sets the select's value. Part of the ControlValueAccessor interface
     * required to integrate with Angular's core forms API.
     *
     * Function `setTimeout()` allows to write value after ngOnInit (happens before it right now),
     * so that we have the input `options` set, and it's shown properly in the dropdown
     * https://github.com/angular/angular/issues/29218#issuecomment-592015773
     * It can be removed after the Angular issue is resolved
     * @param value New value to be written to the model.
     */
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: () => void): void;
    /**
     * Disables the select. Part of the ControlValueAccessor interface required
     * to integrate with Angular's core forms API.
     * @param isDisabled Sets whether the component is disabled.
     */
    setDisabledState(isDisabled: boolean): void;
    /** End ControlValueAccessor */
    _handleKeydown(event: KeyboardEvent): void;
    private get _isLazy();
    private setNextItemActive;
    private setPreviousItemActive;
    private _isSelectable;
    private _handleClosedKeydown;
    private _handleOpenKeydown;
    /** @docs-private */
    formatValue(value: any): string;
    /** Called when the user types in the filter input */
    _onFilter(query: string): void;
    /**
     * The value displayed in the trigger.
     * @docs-private
     */
    get triggerValue(): string;
    _getLabel(option: NxDropdownOption): string;
    /**
     * Callback that is invoked when the overlay panel has been attached.
     */
    _onAttached(): void;
    _onFocus(): void;
    /**
     * Calls the touched callback only if the panel is closed. Otherwise, the trigger will
     * "blur" to the panel when it opens, causing a false positive.
     */
    _onBlur(): void;
    /** @docs-private */
    get isFilterEmpty(): boolean;
    _clearFilter(): void;
    /** Determines the `aria-activedescendant` to be set on the host. */
    _getAriaActiveDescendant(): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxDropdownComponent, [null, null, null, { attribute: "tabindex"; }, { optional: true; }, null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxDropdownComponent, "nx-dropdown", never, { "readonly": { "alias": "readonly"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "verticalAlignCheckmark": { "alias": "verticalAlignCheckmark"; "required": false; }; "options": { "alias": "options"; "required": false; }; "filterInputType": { "alias": "filterInputType"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isMultiSelect": { "alias": "isMultiSelect"; "required": false; }; "required": { "alias": "required"; "required": false; }; "styles": { "alias": "variant"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "ignoreItemTruncation": { "alias": "ignoreItemTruncation"; "required": false; }; "showFilter": { "alias": "showFilter"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "overlayLabel": { "alias": "overlayLabel"; "required": false; }; "overlayFallbackOrigin": { "alias": "overlayFallbackOrigin"; "required": false; }; "panelMaxWidth": { "alias": "panelMaxWidth"; "required": false; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; }; "panelGrow": { "alias": "panelGrow"; "required": false; }; "valueFormatter": { "alias": "valueFormatter"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; }, { "openedChange": "openedChange"; "focusOut": "focusOut"; "filterResultChange": "filterResult"; "_openedStream": "opened"; "_closedStream": "closed"; "filterChanges": "filterInput"; "valueChange": "valueChange"; "selectionChange": "selectionChange"; }, ["_customClosedDropdownLabel", "_contentDropdownItems", "groups"], ["*"], true, never>;
    static ngAcceptInputType_panelGrow: unknown;
}

/**
 * A single option witin the multi select.
 * @docs-private
 */
declare class NxMultiSelectAllComponent<T> implements Highlightable, ListKeyManagerOption {
    private readonly _cdr;
    readonly elementRef: ElementRef;
    private liveAnnouncer;
    private _active;
    id: string;
    /**
     * Value of this option.
     */
    value?: T;
    /**
     * Label of this option.
     */
    label: string;
    /**
     * Indeterminate
     */
    set indeterminate(value: boolean);
    get indeterminate(): boolean;
    _indeterminate: boolean;
    /**
     * Whether this option is selected.
     */
    selected: boolean;
    /**
     * Whether thisoption is disabled.
     */
    disabled: boolean;
    /**
     * Emits an event when this option is selected or unselected by the user.
     */
    readonly selectedAllChange: EventEmitter<boolean>;
    /**
     * Sets this option active highlighting it to the user.
     */
    set active(value: boolean);
    get active(): boolean;
    constructor(_cdr: ChangeDetectorRef, elementRef: ElementRef, liveAnnouncer: LiveAnnouncer);
    setActiveStyles(): void;
    setInactiveStyles(): void;
    _onClick(e: Event): void;
    _onSelect(): void;
    /**
     * Selects this option as if the user clicked on it.
     */
    selectViaInteraction(): void;
    getLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxMultiSelectAllComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxMultiSelectAllComponent<any>, "nx-multi-select-all", never, { "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectedAllChange": "selectedAllChange"; }, never, never, true, never>;
}

/**
 * A single option witin the multi select.
 * @docs-private
 */
declare class NxMultiSelectOptionComponent<T> implements Highlightable, ListKeyManagerOption {
    private readonly _cdr;
    readonly elementRef: ElementRef;
    private liveAnnouncer;
    private _active;
    id: string;
    appearance: AppearanceType;
    /**
     * Value of this option.
     */
    value?: T;
    /**
     * Label of this option.
     */
    label: string;
    /**
     * Whether this option is selected.
     */
    selected: boolean;
    /**
     * Whether thisoption is disabled.
     */
    disabled: boolean;
    /**
     * Emits an event when this option is selected or unselected by the user.
     */
    readonly selectedChange: EventEmitter<boolean>;
    /**
     * Sets this option active highlighting it to the user.
     */
    set active(value: boolean);
    get active(): boolean;
    constructor(_cdr: ChangeDetectorRef, elementRef: ElementRef, liveAnnouncer: LiveAnnouncer);
    setActiveStyles(): void;
    setInactiveStyles(): void;
    _onClick(): void;
    /**
     * Selects this option as if the user clicked on it.
     */
    selectViaInteraction(): void;
    getLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxMultiSelectOptionComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxMultiSelectOptionComponent<any>, "nx-multi-select-option", never, { "appearance": { "alias": "appearance"; "required": false; }; "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
}

type NxMultiSelectFilterFn = (query: string, label: string) => boolean;
/**
 * Multi Select component.
 * @typeParam S Type of the items in the options array
 * @typeParam T Type of the ngModel value
 */
declare class NxMultiSelectComponent<S, T> implements ControlValueAccessor, NxFormfieldControl<T[]>, DoCheck, OnDestroy, AfterViewInit {
    #private;
    readonly _intl: NxDropdownIntl;
    private readonly _elementRef;
    private readonly _errorStateMatcher;
    private readonly _cdr;
    private readonly _formFieldComponent;
    readonly ngControl: NgControl | null;
    private readonly _parentForm;
    private readonly _parentFormGroup;
    get value(): T[];
    get _isOutline(): boolean;
    get _appearance(): AppearanceType;
    get _overlayLabel(): string | null | undefined;
    /**
     * Whether the value is empty.
     */
    get empty(): boolean;
    get focused(): boolean;
    set required(value: boolean);
    get required(): boolean;
    private _required;
    /** Whether the multi select is disabled. */
    set disabled(value: boolean);
    get disabled(): boolean;
    private _disabled;
    /** Whether the multi select should be read only. */
    set readonly(value: BooleanInput);
    get readonly(): boolean;
    private _readonly;
    /** The placeholder shown in the multi select field. */
    set placeholder(value: string);
    get placeholder(): string;
    private _placeholder;
    /**
     * Whether this multi select can be filtered.
     */
    set filter(value: BooleanInput);
    get filter(): boolean;
    private _filter;
    /** Whether the (select all / clear all) should be disabled and hidden. */
    set disableSelectAll(value: BooleanInput);
    get disableSelectAll(): boolean;
    /**
     * Function to be used when the user types into the search filter. The first argument is the user input,
     * the second argument is the dropdown item value as displayed. The dropdown items will use this function
     * to set their visibility state. A boolean should be returned.
     *
     * Defaults to lower case inclusion.
     */
    set filterFn(value: NxMultiSelectFilterFn | null | undefined);
    get filterFn(): NxMultiSelectFilterFn;
    /** @docs-private */
    get shouldLabelFloat(): boolean;
    /** @docs-private */
    get elementRef(): ElementRef;
    get _allSelected(): boolean;
    get _someSelected(): boolean;
    private get _isActiveItemFiltered();
    private _options;
    private _selectAll;
    /** Event emitted when the select panel has been toggled. */
    readonly openedChange: EventEmitter<boolean>;
    /** Event emitted when the select has been opened. */
    readonly _openedStream: Observable<void>;
    /** Event emitted when the select has been closed. */
    readonly _closedStream: Observable<void>;
    private _openedBy;
    /** @docs-private */
    _divider: number;
    private _trigger?;
    private _filterInput?;
    private _optionsList?;
    private _panelHeader?;
    private _panelContent?;
    private _overlayDir?;
    /** Event emitted when the selected value has been changed. */
    readonly selectionChange: EventEmitter<T[]>;
    /** Event emitted when the select panel has been focus out. */
    readonly focusOut: EventEmitter<boolean>;
    /** Event emitted when the user types in the filter input. */
    readonly filterChanges: EventEmitter<any>;
    /** @docs-private */
    readonly controlType: string;
    /** @docs-private */
    errorState: boolean;
    _positions: ConnectionPositionPair[];
    _inputFocused: boolean;
    _ariaDescribedby: string;
    /** Width of the overlay panel. */
    _width: string | number;
    /** Min-width of the overlay panel. */
    _minWidth: string | number;
    _filterValue: string;
    _tooltipText: string;
    listItems: S[];
    selectedItems: Set<S>;
    id: string;
    _comboboxId: string;
    readonly stateChanges: Subject<void>;
    _keyManager: ActiveDescendantKeyManager<NxMultiSelectOptionComponent<T> | NxMultiSelectAllComponent<T>>;
    /** The minimal space between the viewport and the overlay */
    _overlayViewportMargin: number;
    /**
     * List of options to choose from.
     */
    private _option;
    set options(value: S[]);
    get options(): S[];
    /**
     * Placeholder for the filter input.
     */
    filterPlaceholder: string;
    /**
     * Selector to get the value of an option.
     * Can be either a property name or a selector function.
     * When empty the whole option is treated as the value.
     */
    selectValue: string | ((option: S) => T);
    /**
     * Selector to get the label of an option.
     * Can be either a property name or a selector function.
     * When empty the whole option is treated as the label.
     */
    selectLabel: string | ((option: S) => string);
    /**
     * Selector to get the disabled state of an option.
     * Can be either a property name or a selector function.
     */
    selectDisabled?: string | ((option: S) => boolean);
    /**
     * panelGrow: true means the overlay can grow larger than the trigger and grows with the longest label
     * panelGrow: false means the overlay is the size of the trigger
     */
    panelGrow: boolean;
    panelMaxWidth: string | number;
    _isOpen: boolean;
    private readonly _destroyed;
    constructor(_intl: NxDropdownIntl, _elementRef: ElementRef, _errorStateMatcher: ErrorStateMatcher, _cdr: ChangeDetectorRef, _formFieldComponent: NxFormfieldComponent | null, ngControl: NgControl | null, _parentForm: NgForm | null, _parentFormGroup: FormGroupDirective | null);
    ngOnDestroy(): void;
    setDisabledState(isDisabled: boolean): void;
    private _onChange;
    private _onTouched;
    private sortSelectedToTop;
    _selectValue(option: S): T;
    _selectLabel(option: S): string;
    private _updatePositions;
    _isDisabled(option: S): boolean;
    /**
     * Returns html ids of multi select rendered value and label (if available),
     * separated by space.
     */
    _getAriaLabelledBy(): string;
    /** @docs-private */
    setDescribedByIds(ids: string[]): void;
    ngAfterViewInit(): void;
    open($event: Event, origin: FocusOrigin): void;
    _open($event: Event, origin: FocusOrigin): void;
    private getOverlayWidth;
    _close(): void;
    _onSelect(item: S, selected: boolean): void;
    _onKeydown($event: KeyboardEvent): void;
    _onTriggerBlur(): void;
    _onFocusWithinOverlay($event: Event): void;
    _getAriaActiveDescendant(): string | null;
    _onFilterChange(query: string | null | undefined): void;
    _getValueText(): string;
    _onAttach(): void;
    _onDetach(): void;
    _onSelectAll(): void;
    _clear(): void;
    _clearFilter(): void;
    writeValue(value: T[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    ngDoCheck(): void;
    updateErrorState(): void;
    private _updateTooltipText;
    private _scrollActiveOptionIntoView;
    private _initKeyManager;
    static ɵfac: i0.ɵɵFactoryDeclaration<NxMultiSelectComponent<any, any>, [null, null, null, null, { optional: true; }, { optional: true; self: true; }, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NxMultiSelectComponent<any, any>, "nx-multi-select", never, { "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "disableSelectAll": { "alias": "disableSelectAll"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "options": { "alias": "options"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "selectValue": { "alias": "selectValue"; "required": false; }; "selectLabel": { "alias": "selectLabel"; "required": false; }; "selectDisabled": { "alias": "selectDisabled"; "required": false; }; "panelGrow": { "alias": "panelGrow"; "required": false; }; "panelMaxWidth": { "alias": "panelMaxWidth"; "required": false; }; }, { "openedChange": "openedChange"; "_openedStream": "opened"; "_closedStream": "closed"; "selectionChange": "selectionChange"; "focusOut": "focusOut"; "filterChanges": "filterInput"; }, never, never, true, never>;
    static ngAcceptInputType_panelGrow: unknown;
}

declare class NxDropdownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NxDropdownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NxDropdownModule, never, [typeof i1.CommonModule, typeof i2.NxFormfieldModule, typeof i3.NxCheckboxModule, typeof i4.OverlayModule, typeof i5.A11yModule, typeof i6.NxIconModule, typeof i7.ObserversModule, typeof i8.FormsModule, typeof i9.NxTooltipModule, typeof i10.NxButtonModule, typeof i11.NxInputModule, typeof NxDropdownComponent, typeof NxDropdownItemComponent, typeof NxDropdownGroupComponent, typeof NxDropdownClosedLabelDirective, typeof NxMultiSelectComponent, typeof NxMultiSelectOptionComponent, typeof NxMultiSelectAllComponent], [typeof NxDropdownComponent, typeof NxDropdownItemComponent, typeof NxDropdownGroupComponent, typeof NxDropdownClosedLabelDirective, typeof NxMultiSelectComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NxDropdownModule>;
}

/**
 * Directive for select text from current focus element
 */
declare class SelectOnFocusDirective {
    private elementRef;
    constructor(elementRef: ElementRef);
    handleFocus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOnFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectOnFocusDirective, "[selectOnFocus]", never, {}, {}, never, never, true, never>;
}

export { NX_DROPDOWN_SCROLL_STRATEGY, NX_DROPDOWN_SCROLL_STRATEGY_PROVIDER, NX_DROPDOWN_SCROLL_STRATEGY_PROVIDER_FACTORY, NxDropdownClosedLabelDirective, NxDropdownComponent, NxDropdownGroupComponent, NxDropdownIntl, NxDropdownItemChange, NxDropdownItemComponent, NxDropdownModule, NxDropdownSelectChange, NxMultiSelectComponent, NxMultiSelectOptionComponent, SelectOnFocusDirective };
export type { FilterInputType, NxDropdownCompareWithFn, NxDropdownFilterFn, NxDropdownOption, NxDropdownPanelMinWidth, NxDropdownValueFormatterFn, NxMultiSelectFilterFn, VerticalAlignCheckmark };