import * as _angular_core from '@angular/core';
import { InjectionToken, Provider, OnInit, TemplateRef, PipeTransform, OnChanges, OnDestroy, Type, SimpleChanges, ElementRef, AfterViewInit, Signal, EventEmitter, WritableSignal, ChangeDetectorRef } from '@angular/core';
import * as _lucca_front_ng_filter_pills from '@lucca-front/ng/filter-pills';
import { FilterPillInputComponent } from '@lucca-front/ng/filter-pills';
import { OverlayConfig, OverlayRef } from '@angular/cdk/overlay';
import { ControlValueAccessor } from '@angular/forms';
import { PortalContent, LuTranslation } from '@lucca-front/ng/core';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Observable, Subject, ReplaySubject } from 'rxjs';
import { Highlightable } from '@angular/cdk/a11y';

interface ILuOptionContext<T> {
    isDisabled$: BehaviorSubject<boolean>;
    option$: BehaviorSubject<T | undefined>;
    destroy(): void;
}
declare const LU_OPTION_CONTEXT: InjectionToken<ILuOptionContext<unknown>>;
declare function provideOptionContext(): Provider;

declare class LuSimpleSelectDefaultOptionComponent {
    context: ILuOptionContext<{
        name?: string;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuSimpleSelectDefaultOptionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuSimpleSelectDefaultOptionComponent, "lu-simple-select-default-option", never, {}, {}, never, never, true, never>;
}

declare class LuDisabledOptionDirective {
    private context;
    set isDisabled(disabled: boolean | null);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuDisabledOptionDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuDisabledOptionDirective, "[luDisabledOption]", never, { "isDisabled": { "alias": "luDisabledOption"; "required": false; }; }, {}, never, never, true, never>;
}

interface LuOptionContext<T> {
    $implicit: T;
}
interface LuOptionGroupByContext<T, TGroup> {
    $implicit: LuOptionGroup<T, TGroup>;
}
interface LuOptionGroup<T, TGroup> {
    key: TGroup;
    options: T[];
}
type LuOptionComparer<T> = (a: T, b: T) => boolean;
type CoreSelectAddOptionStrategy = 'never' | 'always' | 'if-empty-clue' | 'if-not-empty-clue';
declare const SELECT_ID: InjectionToken<number>;
declare const SELECT_LABEL: InjectionToken<HTMLLabelElement>;
declare const SELECT_LABEL_ID: InjectionToken<string>;
interface CoreSelectApiTotalCountProvider {
    totalCount$: Observable<number>;
}
declare const CORE_SELECT_API_TOTAL_COUNT_PROVIDER: InjectionToken<CoreSelectApiTotalCountProvider>;
declare abstract class ɵIsSelectedStrategy<TOption> {
    abstract isSelected(option: TOption, selectedOptions: TOption[], optionComparer: LuOptionComparer<TOption>): boolean;
    abstract isGroupSelected(options: TOption[], notSelectedOptions: TOption[]): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ɵIsSelectedStrategy<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ɵIsSelectedStrategy<any>>;
}

interface LuOptionGrouping<TOption, TGroup> {
    selector: (option: TOption) => TGroup;
    content: PortalContent<LuOptionGroupByContext<TOption, TGroup>>;
}
declare class LuOptionGroupDirective<TOption, TValue, TGroup> implements LuOptionGrouping<TOption, TGroup>, OnInit {
    select: ALuSelectInputComponent<TOption, TValue>;
    selector: (option: TOption) => TGroup;
    readonly content: TemplateRef<LuOptionGroupByContext<TOption, TGroup>>;
    static ngTemplateContextGuard<TOption, TValue, TGroup>(_dir: LuOptionGroupDirective<TOption, TValue, TGroup>, ctx: unknown): ctx is LuOptionGroupByContext<TOption, TGroup>;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionGroupDirective<any, any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionGroupDirective<any, any, any>, "[luOptionGroup]", never, { "select": { "alias": "luOptionGroupSelect"; "required": false; }; "selector": { "alias": "luOptionGroupBy"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Generate groups with a O(n) complexity. Note that the options must be sorted by group.
 */
declare function generateGroups<T, TGroup>(options: T[], selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>[];
declare class LuOptionGroupPipe<T, TGroup> implements PipeTransform {
    transform(options: T[], selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>[];
    transform(options: T, selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionGroupPipe<any, any>, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LuOptionGroupPipe<any, any>, "luOptionGroup", true>;
}

declare class LuOptionOutletDirective<T> implements OnChanges, OnDestroy {
    luOptionOutlet?: Type<unknown> | TemplateRef<LuOptionContext<T>>;
    luOptionOutletValue: T | undefined;
    luOptionShowNull: boolean;
    private viewContainerRef;
    private injector;
    private embeddedViewRef?;
    private componentRef?;
    private optionContext;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private clearContainer;
    private createComponent;
    private updateRefValue;
    static ngTemplateContextGuard<T>(_dir: LuOptionOutletDirective<T>, ctx: unknown): ctx is void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionOutletDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionOutletDirective<any>, "[luOptionOutlet]", never, { "luOptionOutlet": { "alias": "luOptionOutlet"; "required": false; }; "luOptionOutletValue": { "alias": "luOptionOutletValue"; "required": false; }; "luOptionShowNull": { "alias": "luOptionShowNull"; "required": false; }; }, {}, never, never, true, never>;
}

interface OptionTranslate {
    onlyParent: string;
    onlyChildren: string;
}

type GroupTemplateLocation = 'group-header' | 'option' | 'none';
/**
 * In order to avoid a blinking when we go from empty clue to a clue
 * We need to delay the change of group displayer location by waiting for the options to be updated.
 */
declare function getGroupTemplateLocation(hasGrouping$: Observable<boolean>, clueChange$: Observable<string>, options$: Observable<readonly unknown[]>, searchable?: boolean): Observable<GroupTemplateLocation>;

declare class CoreSelectPanelElement<T> implements Highlightable, OnDestroy {
    #private;
    readonly elementRef: ElementRef<HTMLElement>;
    id: _angular_core.WritableSignal<string>;
    elementId: _angular_core.InputSignal<string>;
    idAttribute: _angular_core.Signal<string>;
    isSelected: _angular_core.ModelSignal<boolean>;
    option: _angular_core.InputSignal<T>;
    isHighlighted: _angular_core.WritableSignal<boolean>;
    selected: _angular_core.OutputEmitterRef<void>;
    disabled: boolean;
    constructor();
    ngOnDestroy(): void;
    setActiveStyles(): void;
    setInactiveStyles(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectPanelElement<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectPanelElement<any>, "[luCoreSelectPanelElement]", ["luCoreSelectPanelElement"], { "elementId": { "alias": "elementId"; "required": false; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "option": { "alias": "option"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "isSelected": "isSelectedChange"; "selected": "selected"; }, never, never, true, never>;
}

declare class LuOptionComponent<T> implements AfterViewInit, OnDestroy, OnInit {
    protected selectableItem: CoreSelectPanelElement<any>;
    readonly intl: _angular_core.InputSignalWithTransform<OptionTranslate, Partial<OptionTranslate>>;
    hasOptionItemClass: boolean;
    optionTpl: TemplateRef<LuOptionContext<T>> | Type<unknown> | undefined;
    option?: T;
    grouping?: LuOptionGrouping<T, unknown>;
    hasChildren: _angular_core.InputSignalWithTransform<boolean, unknown>;
    onlyParent: _angular_core.OutputEmitterRef<void>;
    onlyChildren: _angular_core.OutputEmitterRef<void>;
    groupIndex: _angular_core.InputSignal<number>;
    optionIndex: _angular_core.InputSignalWithTransform<string, string | number>;
    scrollIntoViewOptions: ScrollIntoViewOptions;
    groupTemplateLocation: _angular_core.InputSignal<GroupTemplateLocation>;
    private optionContext?;
    private cdr;
    private subscription?;
    get id(): string;
    protected elementRef: ElementRef<HTMLElement>;
    protected selectId: number;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    selectOption($event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuOptionComponent<any>, "lu-select-option", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; }; "option": { "alias": "option"; "required": false; }; "grouping": { "alias": "grouping"; "required": false; }; "hasChildren": { "alias": "hasChildren"; "required": false; "isSignal": true; }; "groupIndex": { "alias": "groupIndex"; "required": false; "isSignal": true; }; "optionIndex": { "alias": "optionIndex"; "required": true; "isSignal": true; }; "scrollIntoViewOptions": { "alias": "scrollIntoViewOptions"; "required": false; }; "groupTemplateLocation": { "alias": "groupTemplateLocation"; "required": false; "isSignal": true; }; }, { "onlyParent": "onlyParent"; "onlyChildren": "onlyChildren"; }, never, never, true, never>;
}

declare class LuOptionDirective<TOption, TValue> {
    private templateRef;
    set select(select: ALuSelectInputComponent<TOption, TValue>);
    constructor(templateRef: TemplateRef<LuOptionContext<TOption>>);
    static ngTemplateContextGuard<TOption, TValue>(_dir: LuOptionDirective<TOption, TValue>, ctx: unknown): ctx is LuOptionContext<TOption>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionDirective<any, any>, "[luOption]", never, { "select": { "alias": "luOptionSelect"; "required": false; }; }, {}, never, never, true, never>;
}

interface CoreSelectKeyManagerOptions<T> {
    queryList: Signal<readonly CoreSelectPanelElement<T>[]>;
    options$: Observable<readonly T[]>;
    optionComparer: LuOptionComparer<T>;
    activeOptionIdChanged$: EventEmitter<string>;
    clueChange$: Observable<string>;
}
declare class CoreSelectKeyManager<T> {
    #private;
    init(options: CoreSelectKeyManagerOptions<T>): void;
    onKeydown(event: KeyboardEvent): void;
    get activeItem(): CoreSelectPanelElement<T> | undefined;
    get activeItemIndex(): number;
    setActiveItem(index: number): void;
    highlightOption(option: T): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectKeyManager<any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CoreSelectKeyManager<any>>;
}

declare class LuCoreSelectPanelHeaderDirective {
    readonly templateRef: TemplateRef<void>;
    readonly select: _angular_core.InputSignal<ALuSelectInputComponent<unknown, unknown> | ALuSelectInputComponent<unknown, unknown[]>>;
    constructor();
    static ngTemplateContextGuard(_dir: LuCoreSelectPanelHeaderDirective, ctx: unknown): ctx is void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectPanelHeaderDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectPanelHeaderDirective, "[luSelectPanelHeader]", never, { "select": { "alias": "luSelectPanelHeader"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class LuSelectPanelRef<TOption, TValue> {
    closed: EventEmitter<void>;
    previousPage: EventEmitter<void>;
    nextPage: EventEmitter<void>;
    valueChanged: EventEmitter<TValue>;
    clueChanged: EventEmitter<string>;
    activeOptionIdChanged: EventEmitter<string>;
    options$: Observable<TOption>;
    abstract updatePosition(): void;
    abstract handleKeyManagerEvent(event: KeyboardEvent): void;
    abstract emitValue(value: TValue): void;
    abstract selectCurrentlyHighlightedValue(): void;
    close(): void;
}

interface CoreSelectPanelInstance<T = unknown> {
    options: WritableSignal<CoreSelectPanelElement<T>[]>;
}
declare const SELECT_PANEL_INSTANCE: InjectionToken<CoreSelectPanelInstance<unknown>>;

declare const LU_CORE_SELECT_TRANSLATIONS: InjectionToken<LuTranslation<LuCoreSelectLabel>>;
interface LuCoreSelectLabel {
    addOption: string;
}
declare const luCoreSelectTranslations: LuTranslation<LuCoreSelectLabel>;

type TreeGroupingFn<T> = (value: T, array: T[]) => T | null;
interface TreeNode<T> {
    node: T;
    children?: TreeNode<T>[];
}

interface TreeGenerator<T, R extends TreeNode<unknown>> {
    generateTrees(items: T[]): R[];
}

declare const coreSelectDefaultOptionComparer: LuOptionComparer<unknown>;
declare const coreSelectDefaultOptionKey: (option: unknown) => unknown;
declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDestroy, OnInit, ControlValueAccessor, FilterPillInputComponent {
    #private;
    parentInput: FilterPillInputComponent;
    protected changeDetectorRef: ChangeDetectorRef;
    protected overlayContainerRef: HTMLElement;
    protected labelElement: HTMLElement | undefined;
    protected labelId: string;
    protected abstract intl: Signal<LuCoreSelectLabel>;
    protected filterPillHost: _lucca_front_ng_filter_pills.FilterPillComponent;
    protected afterCloseFn?: () => void;
    protected updatePositionFn?: () => void;
    protected filterPillMode: boolean;
    ignorePresentation: _angular_core.InputSignalWithTransform<boolean, unknown>;
    selectParent$?: Subject<void>;
    selectChildren$?: Subject<void>;
    panelClosed: _angular_core.OutputEmitterRef<void>;
    panelOpened: _angular_core.OutputEmitterRef<void>;
    highlightedOption: _angular_core.OutputEmitterRef<TOption>;
    private inputElementRef;
    placeholder$: BehaviorSubject<string>;
    disabled$: BehaviorSubject<boolean>;
    filterPillDisabled: Signal<boolean>;
    prefix: _angular_core.InputSignal<PortalContent>;
    set placeholder(value: string);
    set clearable(value: boolean);
    get clearable(): boolean;
    get searchable(): boolean;
    protected computedAddOptionLabel: Signal<PortalContent>;
    set addOptionLabel(label: PortalContent);
    get addOptionLabel(): PortalContent;
    set addOptionStrategy(strategy: CoreSelectAddOptionStrategy);
    protected get isSelectedClass(): boolean;
    protected get isSearchFilledClass(): boolean;
    protected abstract hasValue(): boolean;
    get isPanelOpen(): boolean;
    isPanelOpen$: BehaviorSubject<boolean>;
    activeDescendant$: BehaviorSubject<string>;
    get ariaControls(): string;
    overlayConfig?: OverlayConfig;
    set loading(value: boolean);
    set options(options: readonly TOption[]);
    optionComparer: LuOptionComparer<TOption>;
    optionKey: (option: TOption) => unknown;
    noClueIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
    inputTabindex: _angular_core.InputSignal<number>;
    compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
    colorPicker: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected get isNoClueIconClass(): boolean;
    optionTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
    valueTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
    panelHeaderTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<void>>;
    panelFooterTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<void>>;
    displayerTpl: Signal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
    groupingSignal: _angular_core.WritableSignal<LuOptionGrouping<TOption, unknown>>;
    /**
     * @deprecated use groupingSignal
     */
    get grouping(): LuOptionGrouping<TOption, unknown> | undefined;
    /**
     * @deprecated use groupingSignal
     */
    set grouping(grouping: LuOptionGrouping<TOption, unknown> | undefined);
    treeGenerator?: TreeGenerator<TOption, TreeNode<TOption>>;
    clueChange$: Subject<string>;
    clueChange: _angular_core.OutputRef<string>;
    nextPage$: Subject<void>;
    nextPage: _angular_core.OutputRef<void>;
    previousPage: _angular_core.OutputEmitterRef<void>;
    addOption: _angular_core.OutputEmitterRef<string>;
    valueSignal: _angular_core.WritableSignal<TValue>;
    isFilterPillEmpty: Signal<boolean>;
    isFilterPillClearable: Signal<boolean>;
    get value(): TValue;
    protected set value(value: TValue);
    get inputPlaceholder(): string | null;
    clueChanged(clue: string, skipPanelOpen?: boolean): void;
    protected _value?: TValue;
    options$: ReplaySubject<readonly TOption[]>;
    loading$: BehaviorSubject<boolean>;
    clue: string | null;
    lastEmittedClue: string;
    clue$: Observable<string>;
    addOptionStrategy$: BehaviorSubject<CoreSelectAddOptionStrategy>;
    shouldDisplayAddOption$: Observable<boolean>;
    protected onChange?: (value: TValue | null) => void;
    protected onTouched?: () => void;
    get panelRef(): LuSelectPanelRef<TOption, TValue> | undefined;
    protected _panelRef?: LuSelectPanelRef<TOption, TValue>;
    protected destroyed$: Subject<void>;
    constructor();
    onClickOpenPanel($event: Event): void;
    onKeyDownNavigation(event: Event): void;
    registerOnChange(onChange: (value: TValue) => void): void;
    registerOnTouched(onTouched: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    clearValue(event?: Event): void;
    openPanel(clue?: string): void;
    emitAddOption(): void;
    protected abstract buildPanelRef(): this['panelRef'];
    protected bindInputToPanelRefEvents(): void;
    focusInput(): void;
    protected emptyClue(): void;
    closePanel(): void;
    writeValue(value: TValue): void;
    updateValue(value: TValue, skipPanelOpen?: boolean, noClear?: boolean): void;
    clearFilterPillValue(): void;
    registerFilterPillClosePopover(closeFn: () => void): void;
    registerFilterPillUpdatePosition(updatePositionFn: () => void): void;
    enableFilterPillMode(): void;
    onFilterPillOpened(): void;
    onFilterPillClosed(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ALuSelectInputComponent<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ALuSelectInputComponent<any, any>, never, never, { "ignorePresentation": { "alias": "ignorePresentation"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "addOptionLabel": { "alias": "addOptionLabel"; "required": false; }; "addOptionStrategy": { "alias": "addOptionStrategy"; "required": false; }; "overlayConfig": { "alias": "overlayConfig"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionComparer": { "alias": "optionComparer"; "required": false; }; "optionKey": { "alias": "optionKey"; "required": false; }; "noClueIcon": { "alias": "noClueIcon"; "required": false; "isSignal": true; }; "inputTabindex": { "alias": "inputTabindex"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "colorPicker": { "alias": "colorPicker"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "valueTpl": { "alias": "valueTpl"; "required": false; "isSignal": true; }; "panelHeaderTpl": { "alias": "panelHeaderTpl"; "required": false; "isSignal": true; }; "panelFooterTpl": { "alias": "panelFooterTpl"; "required": false; "isSignal": true; }; }, { "panelClosed": "panelClosed"; "panelOpened": "panelOpened"; "highlightedOption": "highlightedOption"; "optionTpl": "optionTplChange"; "valueTpl": "valueTplChange"; "panelHeaderTpl": "panelHeaderTplChange"; "panelFooterTpl": "panelFooterTplChange"; "clueChange": "clueChange"; "nextPage": "nextPage"; "previousPage": "previousPage"; "addOption": "addOption"; }, never, never, true, never>;
    static ngAcceptInputType_clearable: unknown;
}

declare function provideLuSelectLabelsAndIds(): Provider[];
declare function addAttributesOnCdkContainer(overlayRef: OverlayRef, selectLabelId: string, selectId: number): void;

declare class LuCoreSelectTotalCountDirective implements CoreSelectApiTotalCountProvider {
    totalCount: _angular_core.InputSignal<number>;
    totalCount$: rxjs.Observable<number>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectTotalCountDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectTotalCountDirective, "lu-simple-select[totalCount],lu-multi-select[totalCount]", never, { "totalCount": { "alias": "totalCount"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TreeDisplayPipe<T> implements PipeTransform {
    transform(items: T[], treeGenerator: TreeGenerator<T, TreeNode<T>>): TreeNode<T>[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeDisplayPipe<any>, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TreeDisplayPipe<any>, "luTreeDisplay", true>;
}

declare class LuDisplayerDirective<TOption, TValue> {
    private templateRef;
    set select(select: ALuSelectInputComponent<TOption, TValue>);
    constructor(templateRef: TemplateRef<LuOptionContext<TOption>>);
    static ngTemplateContextGuard<TOption, TValue>(_dir: LuDisplayerDirective<TOption, TValue>, ctx: unknown): ctx is LuOptionContext<TOption>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuDisplayerDirective<any, any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuDisplayerDirective<any, any>, "[luDisplayer]", never, { "select": { "alias": "luDisplayerSelect"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuCoreSelectNoClueDirective {
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectNoClueDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectNoClueDirective, "lu-simple-select[noClue],lu-multi-select[noClue]", never, {}, {}, never, never, true, never>;
}

declare const applySearchDelimiter: (clue: string, delimiter: string) => string;

declare class LuIsOptionSelectedPipe<T> implements PipeTransform {
    #private;
    transform(option: T, comparer: LuOptionComparer<T>, selectedOptions: T[]): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuIsOptionSelectedPipe<any>, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LuIsOptionSelectedPipe<any>, "luIsOptionSelected", true>;
}

export { ALuSelectInputComponent, CORE_SELECT_API_TOTAL_COUNT_PROVIDER, CoreSelectKeyManager, LU_CORE_SELECT_TRANSLATIONS, LU_OPTION_CONTEXT, LuCoreSelectNoClueDirective, LuCoreSelectPanelHeaderDirective, LuCoreSelectTotalCountDirective, LuDisabledOptionDirective, LuDisplayerDirective, LuIsOptionSelectedPipe, LuOptionDirective, LuOptionGroupDirective, LuSelectPanelRef, LuSimpleSelectDefaultOptionComponent, SELECT_ID, SELECT_LABEL, SELECT_LABEL_ID, SELECT_PANEL_INSTANCE, TreeDisplayPipe, addAttributesOnCdkContainer, applySearchDelimiter, coreSelectDefaultOptionComparer, coreSelectDefaultOptionKey, luCoreSelectTranslations, provideLuSelectLabelsAndIds, provideOptionContext, CoreSelectPanelElement as ɵCoreSelectPanelElement, ɵIsSelectedStrategy, LuOptionComponent as ɵLuOptionComponent, LuOptionGroupPipe as ɵLuOptionGroupPipe, LuOptionOutletDirective as ɵLuOptionOutletDirective, generateGroups as ɵgenerateGroups, getGroupTemplateLocation as ɵgetGroupTemplateLocation };
export type { CoreSelectAddOptionStrategy, CoreSelectApiTotalCountProvider, CoreSelectPanelInstance, ILuOptionContext, LuCoreSelectLabel, LuOptionComparer, LuOptionContext, LuOptionGroup, LuOptionGroupByContext, LuOptionGrouping, TreeGenerator, TreeGroupingFn, TreeNode };