import * as i0 from '@angular/core';
import { ChangeDetectorRef, ElementRef, Injector, ViewContainerRef, OnDestroy, OnInit, Type, TemplateRef, Signal, InjectionToken, DestroyRef } from '@angular/core';
import * as _lucca_front_ng_multi_select from '@lucca-front/ng/multi-select';
import * as _lucca_front_ng_core_select from '@lucca-front/ng/core-select';
import { LuSelectPanelRef, ALuSelectInputComponent, LuOptionContext, ɵIsSelectedStrategy as _IsSelectedStrategy, ILuOptionContext } from '@lucca-front/ng/core-select';
import { ControlValueAccessor, AbstractControl, ValidationErrors } from '@angular/forms';
import * as rxjs from 'rxjs';
import { Subject, BehaviorSubject } from 'rxjs';
import { Overlay, OverlayPositionBuilder, ScrollStrategyOptions, OverlayConfig, ConnectedPosition } from '@angular/cdk/overlay';
import { LuTranslation } from '@lucca-front/ng/core';
import * as i1 from '@lucca-front/ng/form-field';
import { LuOptionComparer } from '@lucca-front/ng/option';

type LuMultiSelection<T> = {
    mode: 'include';
    values: T[];
} | {
    mode: 'exclude';
    values: T[];
} | {
    mode: 'none';
} | {
    mode: 'all';
};
type LuMultiSelectionMode = LuMultiSelection<unknown>['mode'];

declare abstract class LuMultiSelectPanelRef<T> extends LuSelectPanelRef<T, T[]> {
    abstract changeDetectorRef?: ChangeDetectorRef;
    abstract updateSelectedOptions(selectedOptions: T[]): void;
    abstract useDefaultPosition(): void;
}

declare class LuMultiSelectPanelRefFactory {
    protected overlay: Overlay;
    protected elementRef: ElementRef<HTMLElement>;
    protected positionBuilder: OverlayPositionBuilder;
    protected scrollStrategies: ScrollStrategyOptions;
    protected parentInjector: Injector;
    private selectLabelId;
    private selectId;
    buildPanelRef<T>(selectInput: LuMultiSelectInputComponent<T>, defaultOverlayConfigOverride?: OverlayConfig): LuMultiSelectPanelRef<T>;
    buildAndAttachPanelRef<T>(selectInput: LuMultiSelectInputComponent<T>, host: ViewContainerRef): LuMultiSelectPanelRef<T>;
    protected buildDefaultOverlayConfig(overlayConfigOverride?: OverlayConfig): OverlayConfig;
    protected buildPosition(yDirection: 'top' | 'bottom', xDirection: 'left' | 'right', config: {
        offsetX?: number;
        offsetY?: number;
        overlapInput: boolean;
    }): ConnectedPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectPanelRefFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuMultiSelectPanelRefFactory>;
}

declare class LuMultiSelectInputComponent<T> extends ALuSelectInputComponent<T, T[]> implements ControlValueAccessor, OnDestroy, OnInit {
    intl: i0.InputSignalWithTransform<_lucca_front_ng_core_select.LuCoreSelectLabel & _lucca_front_ng_multi_select.ILuMultiSelectLabel, Partial<_lucca_front_ng_core_select.LuCoreSelectLabel & _lucca_front_ng_multi_select.ILuMultiSelectLabel>>;
    showColon: false;
    valuesTpl: i0.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<T[]>>>;
    maxValuesShown: number;
    keepSearchAfterSelection: boolean;
    filterPillLabelPlural: string;
    selectParent$: Subject<void>;
    selectChildren$: Subject<void>;
    get filterPillClass(): boolean;
    hideCombobox: Signal<boolean>;
    filterPillPanelAnchorRef: Signal<ViewContainerRef>;
    isFilterPillEmpty: Signal<boolean>;
    valueLength: Signal<number>;
    useSingleOptionDisplayer: Signal<boolean>;
    _value: T[];
    get panelRef(): LuMultiSelectPanelRef<T> | undefined;
    protected _panelRef?: LuMultiSelectPanelRef<T>;
    protected panelRefFactory: LuMultiSelectPanelRefFactory;
    /**
     * This is used to tell the displayer to focus on the input element
     * keepClue is used to avoid triggering an update which would open the panel,
     * mainly for when we want to focus without opening the panel
     */
    readonly focusInput$: Subject<void | {
        keepClue: boolean;
    }>;
    readonly emptyClue$: Subject<void>;
    selectParentOnly(): void;
    selectChildrenOnly(): void;
    focusInput(): void;
    emptyClue(): void;
    writeValue(value: T[]): void;
    updateValue(value: T[], skipFocus?: boolean): void;
    updatePosition(): void;
    protected buildPanelRef(): LuMultiSelectPanelRef<T>;
    protected bindInputToPanelRefEvents(): void;
    enableFilterPillMode(): void;
    hasValue(): boolean;
    clearValue(event?: Event): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectInputComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuMultiSelectInputComponent<any>, "lu-multi-select", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "valuesTpl": { "alias": "valuesTpl"; "required": false; "isSignal": true; }; "maxValuesShown": { "alias": "maxValuesShown"; "required": false; }; "keepSearchAfterSelection": { "alias": "keepSearchAfterSelection"; "required": false; }; "filterPillLabelPlural": { "alias": "filterPillLabelPlural"; "required": false; }; }, { "valuesTpl": "valuesTplChange"; }, never, never, true, never>;
    static ngAcceptInputType_maxValuesShown: unknown;
    static ngAcceptInputType_keepSearchAfterSelection: unknown;
}

declare const LU_MULTI_SELECT_TRANSLATIONS: InjectionToken<LuTranslation<ILuMultiSelectLabel>>;
interface ILuMultiSelectLabel {
    placeholder: string;
    search: string;
    clear: string;
    clearSearch: string;
    emptyResults: string;
    emptyOptions: string;
    emptySelection: string;
    expand: string;
    reduce: string;
    selectAll: string;
    unselectAll: string;
    loading: string;
}
declare const luMultiSelectTranslations: LuTranslation<ILuMultiSelectLabel>;

interface LuMultiSelectWithSelectAllContext {
    setSelectAll(value: boolean): void;
    mode: Signal<LuMultiSelectionMode>;
    values: Signal<unknown[]>;
    displayerLabel: Signal<string>;
    totalCount: Signal<number>;
    displayerCount: Signal<number>;
    intl: Signal<ILuMultiSelectLabel>;
}

declare class LuMultiSelectWithSelectAllDirective<TValue> extends _IsSelectedStrategy<TValue> implements LuMultiSelectWithSelectAllContext {
    #private;
    readonly select: LuMultiSelectInputComponent<TValue>;
    readonly intl: i0.InputSignalWithTransform<_lucca_front_ng_core_select.LuCoreSelectLabel & _lucca_front_ng_multi_select.ILuMultiSelectLabel, Partial<_lucca_front_ng_core_select.LuCoreSelectLabel & _lucca_front_ng_multi_select.ILuMultiSelectLabel>>;
    readonly displayerLabel: i0.InputSignal<string>;
    readonly mode: i0.Signal<"include" | "exclude" | "none" | "all">;
    readonly values: i0.Signal<TValue[]>;
    readonly totalCount: i0.Signal<number>;
    readonly displayerCount: i0.Signal<number>;
    constructor();
    setSelectAll(selectAll: boolean): void;
    isSelected(option: TValue, selectedOptions: TValue[], optionComparer: LuOptionComparer<TValue>): boolean;
    isGroupSelected(_options: TValue[], notSelectedOptions: TValue[]): boolean;
    registerOnChange(fn: (value: TValue[] | LuMultiSelection<TValue>) => void): void;
    writeValue(value: TValue[] | LuMultiSelection<TValue>): void;
    clearValue($event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectWithSelectAllDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuMultiSelectWithSelectAllDirective<any>, "lu-multi-select[withSelectAll]", never, { "displayerLabel": { "alias": "withSelectAllDisplayerLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LuMultiSelectContentDisplayerComponent<T> {
    select: LuMultiSelectInputComponent<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectContentDisplayerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuMultiSelectContentDisplayerComponent<any>, "lu-multi-select-content-displayer", never, {}, {}, never, ["*"], true, never>;
}

declare class LuMultiSelectCounterDisplayerComponent<T> implements OnInit {
    select: LuMultiSelectInputComponent<T>;
    context: ILuOptionContext<T[]>;
    protected destroyRef: DestroyRef;
    inputElementRef: ElementRef<HTMLInputElement>;
    get value(): T[];
    selectedOptions$: BehaviorSubject<T[]>;
    set selected(options: T[]);
    label: string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectCounterDisplayerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuMultiSelectCounterDisplayerComponent<any>, "lu-multi-select-counter-displayer", never, { "selected": { "alias": "selected"; "required": false; }; "label": { "alias": "label"; "required": true; }; }, {}, never, never, true, never>;
}

declare class LuMultiSelectDefaultDisplayerComponent<T> implements OnInit {
    select: LuMultiSelectInputComponent<T>;
    intl: i0.InputSignalWithTransform<_lucca_front_ng_multi_select.ILuMultiSelectDisplayerLabel, Partial<_lucca_front_ng_multi_select.ILuMultiSelectDisplayerLabel>>;
    protected destroyRef: DestroyRef;
    inputElementRef: ElementRef<HTMLInputElement>;
    get value(): T[];
    context: ILuOptionContext<T[]>;
    displayedOptions$: rxjs.Observable<T[]>;
    overflowOptions$: rxjs.Observable<number>;
    unselectOption(option: T, $event?: Event): void;
    inputBackspace(): void;
    inputSpace(event: Event): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectDefaultDisplayerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuMultiSelectDefaultDisplayerComponent<any>, "lu-multi-select-default-displayer", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const LU_MULTI_SELECT_DISPLAYER_TRANSLATIONS: InjectionToken<LuTranslation<ILuMultiSelectDisplayerLabel>>;
interface ILuMultiSelectDisplayerLabel {
    otherResult: string;
    otherResults: string;
    showResultsDetails: string;
    removeOption: string;
}
declare const luMultiSelectDisplayerTranslations: LuTranslation<ILuMultiSelectDisplayerLabel>;

declare class LuMultiSelectDisplayerInputDirective<T> implements OnInit {
    #private;
    select: LuMultiSelectInputComponent<T>;
    readonly selectAllContext: LuMultiSelectWithSelectAllContext;
    contentDisplayer: LuMultiSelectContentDisplayerComponent<any>;
    context: ILuOptionContext<T[]>;
    elementRef: ElementRef<HTMLInputElement>;
    destroyRef: DestroyRef;
    get panelOpen(): boolean;
    get activeDescendant(): string;
    get controls(): string;
    get disabled(): boolean;
    get placeholder(): string;
    get readonly(): boolean;
    onInput(): void;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectDisplayerInputDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuMultiSelectDisplayerInputDirective<any>, "[luMultiSelectDisplayerInput]", never, {}, {}, never, never, true, [{ directive: typeof i1.InputDirective; inputs: {}; outputs: {}; }]>;
}

declare class LuMultiDisplayerDirective<T> {
    private templateRef;
    set select(select: LuMultiSelectInputComponent<T>);
    constructor(templateRef: TemplateRef<LuOptionContext<T[]>>);
    static ngTemplateContextGuard<T>(_dir: LuMultiDisplayerDirective<T>, ctx: unknown): ctx is LuOptionContext<T[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiDisplayerDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuMultiDisplayerDirective<any>, "[luMultiDisplayer]", never, { "select": { "alias": "luMultiDisplayerSelect"; "required": false; }; }, {}, never, never, true, never>;
}

declare function selectionToQueryParams<T, Key extends string>(key: Key, value: LuMultiSelection<T>, selector: (value: T) => unknown): Partial<Record<Key | `-${Key}`, string>>;
/**
 * Transforms a selection from withSelectAll, the complete list of options and a getKey function to a list of options.
 *
 * @example
 * ```ts
 * const selection = { mode: 'exclude', values: [{ id: 1, name: 'foo' }] };
 * const allOptions = [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }, { id: 3, name: 'baz' }];
 *
 * const selectedOptions = selectionToOptions(selection, allOptions, (o) => o.id);
 * ```
 */
declare function selectionToOptions<T>(selection: LuMultiSelection<T>, options: T[], getKeyFn: (value: T) => unknown): T[];

declare const LuMultiSelectionValidators: {
    required: (control: AbstractControl<LuMultiSelection<unknown>>) => ValidationErrors | null;
};

export { LU_MULTI_SELECT_DISPLAYER_TRANSLATIONS, LU_MULTI_SELECT_TRANSLATIONS, LuMultiDisplayerDirective, LuMultiSelectContentDisplayerComponent, LuMultiSelectCounterDisplayerComponent, LuMultiSelectDefaultDisplayerComponent, LuMultiSelectDisplayerInputDirective, LuMultiSelectInputComponent, LuMultiSelectWithSelectAllDirective, LuMultiSelectionValidators, luMultiSelectDisplayerTranslations, luMultiSelectTranslations, selectionToOptions, selectionToQueryParams };
export type { ILuMultiSelectDisplayerLabel, ILuMultiSelectLabel, LuMultiSelection, LuMultiSelectionMode };