@lucca-front/ng 19.3.4 → 20.0.0

package/core-select/index.d.ts

@@ -1,5 +1,319 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider, OnInit, TemplateRef, PipeTransform, OnChanges, OnDestroy, Type, SimpleChanges, AfterViewInit, ElementRef, QueryList, EventEmitter, 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 { LuTranslation, PortalContent } from '@lucca-front/ng/core';
+import { OverlayConfig, OverlayRef } from '@angular/cdk/overlay';
+import { ControlValueAccessor } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
+import { Highlightable } from '@angular/cdk/a11y';
+
+declare const LU_CORE_SELECT_TRANSLATIONS: InjectionToken<LuTranslation<LuCoreSelectLabel>>;
+interface LuCoreSelectLabel {
+    addOption: string;
+}
+declare const luCoreSelectTranslations: LuTranslation<LuCoreSelectLabel>;
+
+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: i0.ɵɵFactoryDeclaration<LuSimpleSelectDefaultOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuSimpleSelectDefaultOptionComponent, "lu-simple-select-default-option", never, {}, {}, never, never, true, never>;
+}
+
+declare class LuDisabledOptionDirective {
+    private context;
+    set isDisabled(disabled: boolean | null);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDisabledOptionDirective, never>;
+    static ɵdir: i0.ɵɵ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>;
+
+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: i0.ɵɵFactoryDeclaration<LuOptionGroupDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuOptionGroupDirective<any, any, any>, "[luOptionGroup]", never, { "select": { "alias": "luOptionGroupSelect"; "required": false; }; "selector": { "alias": "luOptionGroupBy"; "required": false; }; }, {}, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Generate groups with a O(n) complexity. Note that the options must be sorted by group.
  */
-/// <amd-module name="@lucca-front/ng/core-select" />
-export * from './public-api';
+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: i0.ɵɵFactoryDeclaration<LuOptionGroupPipe<any, any>, never>;
+    static ɵpipe: i0.ɵɵ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: i0.ɵɵFactoryDeclaration<LuOptionOutletDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuOptionOutletDirective<any>, "[luOptionOutlet]", never, { "luOptionOutlet": { "alias": "luOptionOutlet"; "required": false; }; "luOptionOutletValue": { "alias": "luOptionOutletValue"; "required": false; }; "luOptionShowNull": { "alias": "luOptionShowNull"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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: boolean, clueChange$: Observable<string>, options$: Observable<readonly unknown[]>, searchable?: boolean): Observable<GroupTemplateLocation>;
+
+declare class LuOptionComponent<T> implements Highlightable, AfterViewInit, OnDestroy {
+    hasOptionItemClass: boolean;
+    optionTpl: TemplateRef<LuOptionContext<T>> | Type<unknown> | undefined;
+    isSelected: boolean;
+    option?: T;
+    grouping?: LuOptionGrouping<T, unknown>;
+    groupIndex: i0.InputSignal<number>;
+    optionIndex: number;
+    scrollIntoViewOptions: ScrollIntoViewOptions;
+    groupTemplateLocation: i0.InputSignal<GroupTemplateLocation>;
+    isHighlighted$: BehaviorSubject<boolean>;
+    /**
+     * Whether option is disabled. Used by ListKeyManager.
+     */
+    disabled: boolean;
+    private optionContext?;
+    private cdr;
+    private subscription?;
+    role: string;
+    get id(): string;
+    protected elementRef: ElementRef<HTMLElement>;
+    protected selectId: number;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    selectOption($event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionComponent<any>, "lu-select-option", never, { "optionTpl": { "alias": "optionTpl"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "option": { "alias": "option"; "required": false; }; "grouping": { "alias": "grouping"; "required": false; }; "groupIndex": { "alias": "groupIndex"; "required": false; "isSignal": true; }; "optionIndex": { "alias": "optionIndex"; "required": false; }; "scrollIntoViewOptions": { "alias": "scrollIntoViewOptions"; "required": false; }; "groupTemplateLocation": { "alias": "groupTemplateLocation"; "required": false; "isSignal": true; }; }, {}, 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: i0.ɵɵFactoryDeclaration<LuOptionDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuOptionDirective<any, any>, "[luOption]", never, { "select": { "alias": "luOptionSelect"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface CoreSelectKeyManagerOptions<T> {
+    queryList: QueryList<LuOptionComponent<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(): LuOptionComponent<T> | undefined;
+    get activeItemIndex(): number;
+    setActiveItem(index: number): void;
+    highlightOption(option: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreSelectKeyManager<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoreSelectKeyManager<any>>;
+}
+
+declare class LuCoreSelectPanelHeaderDirective {
+    readonly templateRef: TemplateRef<void>;
+    readonly select: i0.InputSignal<ALuSelectInputComponent<unknown, unknown>>;
+    constructor();
+    static ngTemplateContextGuard(_dir: LuCoreSelectPanelHeaderDirective, ctx: unknown): ctx is void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectPanelHeaderDirective, never>;
+    static ɵdir: i0.ɵɵ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;
+}
+
+declare const coreSelectDefaultOptionComparer: LuOptionComparer<unknown>;
+declare const coreSelectDefaultOptionKey: (option: unknown) => unknown;
+declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDestroy, OnInit, ControlValueAccessor, FilterPillInputComponent {
+    #private;
+    protected changeDetectorRef: ChangeDetectorRef;
+    protected overlayContainerRef: HTMLElement;
+    protected labelElement: HTMLElement | undefined;
+    protected labelId: string;
+    protected coreIntl: LuCoreSelectLabel;
+    protected filterPillHost: _lucca_front_ng_filter_pills.FilterPillComponent;
+    protected afterCloseFn?: () => void;
+    protected updatePositionFn?: () => void;
+    protected filterPillMode: boolean;
+    private inputElementRef;
+    placeholder$: BehaviorSubject<string>;
+    disabled$: BehaviorSubject<boolean>;
+    filterPillDisabled: i0.Signal<boolean>;
+    set placeholder(value: string);
+    set clearable(value: boolean);
+    get clearable(): boolean;
+    get searchable(): boolean;
+    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: i0.InputSignalWithTransform<boolean, unknown>;
+    inputTabindex: i0.InputSignal<number>;
+    protected get isNoClueIconClass(): boolean;
+    optionTpl: i0.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
+    valueTpl: i0.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
+    panelHeaderTpl: i0.ModelSignal<Type<unknown> | TemplateRef<void>>;
+    displayerTpl: i0.Signal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
+    grouping?: LuOptionGrouping<TOption, unknown>;
+    clueChange: EventEmitter<string>;
+    nextPage: EventEmitter<void>;
+    previousPage: EventEmitter<void>;
+    addOption: EventEmitter<string>;
+    valueSignal: i0.WritableSignal<TValue>;
+    isFilterPillEmpty: i0.Signal<boolean>;
+    isFilterPillClearable: i0.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: KeyboardEvent): void;
+    onKeyDownNavigation($event: KeyboardEvent): 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: i0.ɵɵFactoryDeclaration<ALuSelectInputComponent<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuSelectInputComponent<any, any>, never, never, { "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; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "valueTpl": { "alias": "valueTpl"; "required": false; "isSignal": true; }; "panelHeaderTpl": { "alias": "panelHeaderTpl"; "required": false; "isSignal": true; }; }, { "optionTpl": "optionTplChange"; "valueTpl": "valueTplChange"; "panelHeaderTpl": "panelHeaderTplChange"; "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: i0.InputSignal<number>;
+    totalCount$: rxjs.Observable<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectTotalCountDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuCoreSelectTotalCountDirective, "lu-simple-select[totalCount],lu-multi-select[totalCount]", never, { "totalCount": { "alias": "totalCount"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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: i0.ɵɵFactoryDeclaration<LuDisplayerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuDisplayerDirective<any, any>, "[luDisplayer]", never, { "select": { "alias": "luDisplayerSelect"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuCoreSelectNoClueDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectNoClueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuCoreSelectNoClueDirective, "lu-simple-select[noClue],lu-multi-select[noClue]", never, {}, {}, never, never, true, never>;
+}
+
+declare const applySearchDelimiter: (clue: string, delimiter: string) => string;
+
+export { ALuSelectInputComponent, CORE_SELECT_API_TOTAL_COUNT_PROVIDER, CoreSelectKeyManager, LU_CORE_SELECT_TRANSLATIONS, LU_OPTION_CONTEXT, LuCoreSelectNoClueDirective, LuCoreSelectPanelHeaderDirective, LuCoreSelectTotalCountDirective, LuDisabledOptionDirective, LuDisplayerDirective, LuOptionDirective, LuOptionGroupDirective, LuSelectPanelRef, LuSimpleSelectDefaultOptionComponent, SELECT_ID, SELECT_LABEL, SELECT_LABEL_ID, addAttributesOnCdkContainer, applySearchDelimiter, coreSelectDefaultOptionComparer, coreSelectDefaultOptionKey, luCoreSelectTranslations, provideLuSelectLabelsAndIds, provideOptionContext, LuOptionComponent as ɵLuOptionComponent, LuOptionGroupPipe as ɵLuOptionGroupPipe, LuOptionOutletDirective as ɵLuOptionOutletDirective, generateGroups as ɵgenerateGroups, getGroupTemplateLocation as ɵgetGroupTemplateLocation };
+export type { CoreSelectAddOptionStrategy, CoreSelectApiTotalCountProvider, ILuOptionContext, LuCoreSelectLabel, LuOptionComparer, LuOptionContext, LuOptionGroup, LuOptionGroupByContext, LuOptionGrouping };

package/core-select/job-qualification/index.d.ts

@@ -1,5 +1,32 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/core-select/job-qualification" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { CoreSelectApiTotalCountProvider } from '@lucca-front/ng/core-select';
+import { ALuCoreSelectApiDirective } from '@lucca-front/ng/core-select/api';
+import { Observable } from 'rxjs';
+import { ILuApiItem } from '@lucca-front/ng/api';
+
+type LuCoreSelectJob = ILuApiItem;
+type LuCoreSelectJobQualificationLevel = ILuApiItem;
+interface LuCoreSelectJobQualification extends ILuApiItem {
+    job: LuCoreSelectJob;
+    level: LuCoreSelectJobQualificationLevel;
+}
+
+declare class LuCoreSelectJobQualificationsDirective<T extends LuCoreSelectJobQualification = LuCoreSelectJobQualification> extends ALuCoreSelectApiDirective<T> implements OnInit, CoreSelectApiTotalCountProvider {
+    protected httpClient: HttpClient;
+    url: _angular_core.InputSignal<string>;
+    filters: _angular_core.InputSignal<Record<string, string | number | boolean>>;
+    searchDelimiter: _angular_core.InputSignal<string>;
+    protected clue: _angular_core.Signal<string>;
+    constructor();
+    protected getOptions(params: Record<string, string | number | boolean> | null, page: number): Observable<T[]>;
+    protected params$: Observable<Record<string, string | number | boolean>>;
+    totalCount$: Observable<number>;
+    protected optionKey: (option: T) => number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectJobQualificationsDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectJobQualificationsDirective<any>, "lu-simple-select[jobQualifications],lu-multi-select[jobQualifications]", ["jobQualifications"], { "url": { "alias": "url"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "searchDelimiter": { "alias": "searchDelimiter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { LuCoreSelectJobQualificationsDirective };
+export type { LuCoreSelectJob, LuCoreSelectJobQualification, LuCoreSelectJobQualificationLevel };

package/core-select/user/index.d.ts

@@ -1,5 +1,82 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/core-select/user" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { Provider, InjectionToken, Type, TemplateRef } from '@angular/core';
+import { ILuApiItem } from '@lucca-front/ng/api';
+import { LuTranslation } from '@lucca-front/ng/core';
+import { HttpClient } from '@angular/common/http';
+import { CoreSelectApiTotalCountProvider, LuOptionContext } from '@lucca-front/ng/core-select';
+import { ALuCoreSelectApiDirective } from '@lucca-front/ng/core-select/api';
+import { LuDisplayFormat } from '@lucca-front/ng/user';
+import { Observable } from 'rxjs';
+
+declare function provideCoreSelectCurrentUserId(factory: () => number): Provider;
+
+interface LuCoreSelectUser extends ILuApiItem {
+    firstName: string;
+    lastName: string;
+    picture?: {
+        href: string;
+    };
+}
+type LuCoreSelectWithAdditionnalInformation<T> = T & {
+    additionalInformation?: string;
+};
+
+declare const LU_CORE_SELECT_USER_TRANSLATIONS: InjectionToken<LuTranslation<LuCoreSelectUserTranslations>>;
+interface LuCoreSelectUserTranslations {
+    me: string;
+    includeFormerEmployees: string;
+}
+declare const luCoreSelectUserTranslations: LuTranslation<LuCoreSelectUserTranslations>;
+
+declare function provideCoreSelectUsersContext<T extends LuCoreSelectUser = LuCoreSelectUser>(directiveFn: () => Type<LuCoreSelectUsersDirective<T>>): Provider[];
+declare class LuCoreSelectUsersDirective<T extends LuCoreSelectUser = LuCoreSelectUser> extends ALuCoreSelectApiDirective<LuCoreSelectWithAdditionnalInformation<T>> implements CoreSelectApiTotalCountProvider {
+    #private;
+    protected httpClient: HttpClient;
+    currentUserId: number;
+    displayFormat: _angular_core.InputSignal<LuDisplayFormat>;
+    filters: _angular_core.InputSignal<Record<string, string | number | boolean>>;
+    url: _angular_core.InputSignal<string>;
+    orderBy: _angular_core.InputSignal<string>;
+    operationIds: _angular_core.InputSignal<readonly number[]>;
+    uniqueOperationIds: _angular_core.InputSignal<readonly number[]>;
+    appInstanceId: _angular_core.InputSignal<number>;
+    enableFormerEmployees: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    displayMeOption: _angular_core.InputSignal<boolean>;
+    customUserOptionTpl: _angular_core.ModelSignal<TemplateRef<LuOptionContext<T>> | Type<unknown>>;
+    includeFormerEmployees: _angular_core.WritableSignal<boolean>;
+    searchDelimiter: _angular_core.InputSignal<string>;
+    constructor();
+    protected defaultUrl: _angular_core.Signal<string>;
+    protected urlOrDefault: _angular_core.Signal<string>;
+    protected clue: _angular_core.Signal<string>;
+    protected params$: Observable<Record<string, string | number | boolean>>;
+    protected meParams$: Observable<{
+        id: number;
+        appInstanceId?: number;
+        operations?: string;
+        fields: string;
+    }>;
+    protected me$: Observable<T>;
+    totalCount$: Observable<number>;
+    protected getMe(): Observable<T | null>;
+    protected getOptions(params: Record<string, string | number | boolean>, page: number): Observable<T[]>;
+    protected getOptionsPage(params: Record<string, string | number | boolean>, page: number): Observable<{
+        items: LuCoreSelectWithAdditionnalInformation<T>[];
+        isLastPage: boolean;
+    }>;
+    protected optionKey: (option: T) => number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectUsersDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectUsersDirective<any>, "lu-simple-select[users],lu-multi-select[users]", ["luUsers"], { "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "orderBy": { "alias": "orderBy"; "required": false; "isSignal": true; }; "operationIds": { "alias": "operationIds"; "required": false; "isSignal": true; }; "uniqueOperationIds": { "alias": "uniqueOperationIds"; "required": false; "isSignal": true; }; "appInstanceId": { "alias": "appInstanceId"; "required": false; "isSignal": true; }; "enableFormerEmployees": { "alias": "enableFormerEmployees"; "required": false; "isSignal": true; }; "displayMeOption": { "alias": "displayMeOption"; "required": false; "isSignal": true; }; "customUserOptionTpl": { "alias": "customUserOptionTpl"; "required": false; "isSignal": true; }; "searchDelimiter": { "alias": "searchDelimiter"; "required": false; "isSignal": true; }; }, { "customUserOptionTpl": "customUserOptionTplChange"; }, never, never, true, never>;
+}
+declare class LuCoreSelectUserOptionDirective<T extends LuCoreSelectUser = LuCoreSelectUser> {
+    #private;
+    set usersDirective(usersDirective: LuCoreSelectUsersDirective<T>);
+    static ngTemplateContextGuard<T extends LuCoreSelectUser>(_dir: LuCoreSelectUserOptionDirective<T>, ctx: unknown): ctx is {
+        $implicit: T;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectUserOptionDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectUserOptionDirective<any>, "[luUserOption]", never, { "usersDirective": { "alias": "luUserOptionUsersRef"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { LU_CORE_SELECT_USER_TRANSLATIONS, LuCoreSelectUserOptionDirective, LuCoreSelectUsersDirective, luCoreSelectUserTranslations, provideCoreSelectCurrentUserId, provideCoreSelectUsersContext };
+export type { LuCoreSelectUser, LuCoreSelectUserTranslations, LuCoreSelectWithAdditionnalInformation };