@lucca-front/ng 19.3.4 → 20.0.0

package/icon/index.d.ts

@@ -1,5 +1,16 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/icon" />
-export * from './public-api';
+import { LuccaIcon } from '@lucca-front/icons';
+import * as i0 from '@angular/core';
+
+declare class IconComponent {
+    icon: LuccaIcon;
+    alt: string;
+    size: 'XXS' | 'XS' | 'S' | 'M' | 'L' | 'XL' | 'XXL';
+    color: 'primary' | 'secondary' | 'product' | 'error' | 'warning' | 'success' | 'light' | 'placeholder' | 'inherit';
+    get iconClasses(): {
+        [x: string]: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "lu-icon", never, { "icon": { "alias": "icon"; "required": true; }; "alt": { "alias": "alt"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { IconComponent };

package/index.d.ts

@@ -1,5 +1,2 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng" />
-export * from './public_api';
+
+export { };

package/inline-message/index.d.ts

@@ -1,5 +1,21 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/inline-message" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnChanges } from '@angular/core';
+import { PortalContent } from '@lucca-front/ng/core';
+
+type InlineMessageState = 'success' | 'warning' | 'error' | 'default';
+
+declare class InlineMessageComponent implements OnChanges {
+    #private;
+    label: PortalContent;
+    state: InlineMessageState;
+    size: 'S' | 'M';
+    withTooltip: boolean;
+    ngOnChanges(): void;
+    isStringPortalContent(message: PortalContent): message is string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineMessageComponent, "lu-inline-message", never, { "label": { "alias": "label"; "required": true; }; "state": { "alias": "state"; "required": false; }; "size": { "alias": "size"; "required": false; }; "withTooltip": { "alias": "withTooltip"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_withTooltip: unknown;
+}
+
+export { InlineMessageComponent };
+export type { InlineMessageState };

package/input/index.d.ts

@@ -1,5 +1,104 @@
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { EventEmitter, ViewRef, TemplateRef, ChangeDetectorRef, ElementRef, Renderer2, OnInit } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+
+interface ILuClearer<T> {
+    onClear: Observable<T>;
+}
+declare abstract class ALuClearer<T> implements ILuClearer<T> {
+    onClear: Observable<T>;
+}
+
+interface LuClearerLabel {
+    clear: string;
+}
+
+declare class LuInputClearerComponent<T> extends ALuClearer<T> implements ILuClearer<T> {
+    intl: LuClearerLabel;
+    onClear: EventEmitter<T>;
+    onClick($event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputClearerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuInputClearerComponent<any>, "lu-input-clearer", ["luClearer"], {}, { "onClear": "onClear"; }, never, never, true, never>;
+}
+
+declare class LuInputClearerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputClearerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuInputClearerModule, never, [typeof LuInputClearerComponent], [typeof LuInputClearerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuInputClearerModule>;
+}
+
+interface ILuInputDisplayer<T> {
+    multiple: boolean;
+    getViewRef(value: T | T[]): ViewRef;
+}
+declare abstract class ALuInputDisplayer<T> implements ILuInputDisplayer<T> {
+    multiple: boolean;
+    abstract getViewRef(value: T | T[]): ViewRef;
+}
+
+declare class LuInputDisplayerDirective<T> extends ALuInputDisplayer<T> implements ILuInputDisplayer<T> {
+    protected template: TemplateRef<LuInputDisplayerContext<T>>;
+    set argMultiple(m: boolean);
+    set inputMultiple(m: boolean | string);
+    constructor(template: TemplateRef<LuInputDisplayerContext<T>>);
+    getViewRef(value: T | T[]): ViewRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputDisplayerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuInputDisplayerDirective<any>, "[luDisplayer]", never, { "argMultiple": { "alias": "luDisplayerMultiple"; "required": false; }; "inputMultiple": { "alias": "multiple"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class LuInputDisplayerContext<T> {
+    $implicit: T | T[];
+    constructor($implicit: T | T[]);
+}
+
+declare class LuInputDisplayerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputDisplayerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuInputDisplayerModule, never, [typeof LuInputDisplayerDirective], [typeof LuInputDisplayerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuInputDisplayerModule>;
+}
+
+type ILuInput = ControlValueAccessor;
+declare abstract class ALuInput<T, U extends HTMLElement = HTMLElement> implements ILuInput {
+    protected _changeDetectorRef: ChangeDetectorRef;
+    protected _elementRef: ElementRef<U>;
+    protected _renderer: Renderer2;
+    protected _placeholder: string;
+    get placeholder(): string;
+    protected _value: T;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<U>, _renderer: Renderer2);
+    setValue(value: T): void;
+    get value(): T;
+    set value(value: T);
+    writeValue(value: T): void;
+    protected _cvaOnChange: (value: T) => void;
+    registerOnChange(fn: (value: T) => void): void;
+    protected _onTouched: () => void;
+    registerOnTouched(fn: () => void): void;
+    protected isEmpty(): boolean;
+    protected applyClasses(): void;
+    protected abstract render(): void;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * adds class is-filled when model is empty
  */
-/// <amd-module name="@lucca-front/ng/input" />
-export * from './public-api';
+declare class LuInputDirective implements OnInit {
+    protected _elementRef: ElementRef;
+    protected _renderer: Renderer2;
+    protected _ngControl: NgControl;
+    constructor(_elementRef: ElementRef, _renderer: Renderer2, _ngControl: NgControl);
+    protected isEmpty(value: any): boolean;
+    protected applyClasses(value: any): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuInputDirective, "[luInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class LuInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuInputModule, never, [typeof LuInputDirective, typeof LuInputDisplayerDirective, typeof LuInputClearerComponent], [typeof LuInputDirective, typeof LuInputDisplayerDirective, typeof LuInputClearerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuInputModule>;
+}
+
+export { ALuClearer, ALuInput, ALuInputDisplayer, LuInputClearerComponent, LuInputClearerModule, LuInputDirective, LuInputDisplayerContext, LuInputDisplayerDirective, LuInputDisplayerModule, LuInputModule };
+export type { ILuClearer, ILuInput, ILuInputDisplayer };

package/link/index.d.ts

@@ -1,5 +1,29 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/link" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import * as _angular_router from '@angular/router';
+
+interface LinkTranslate {
+    external: string;
+}
+
+declare class LinkComponent implements OnDestroy {
+    #private;
+    intl: LinkTranslate;
+    routerLinkCommands: _angular_core.InputSignal<string | readonly any[] | _angular_router.UrlTree>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    decorationHover: boolean;
+    external: boolean;
+    get relAttr(): string;
+    get targetAttr(): string;
+    get roleAttr(): string;
+    get disabledClass(): boolean;
+    hrefBackup: string;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LinkComponent, "a[luLink], button[luLink]", never, { "routerLinkCommands": { "alias": "luLink"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "decorationHover": { "alias": "decorationHover"; "required": false; }; "external": { "alias": "external"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof _angular_router.RouterLink; inputs: { "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; }; outputs: {}; }]>;
+    static ngAcceptInputType_decorationHover: unknown;
+    static ngAcceptInputType_external: unknown;
+}
+
+export { LinkComponent };

package/modal/index.d.ts

@@ -1,5 +1,161 @@
+import * as i0 from '@angular/core';
+import { ChangeDetectionStrategy, InjectionToken, OnDestroy, DoCheck, ViewContainerRef, ElementRef, Renderer2, Type, Injector, ApplicationRef, ComponentRef, Provider } from '@angular/core';
+import { ILuPopupConfig, ALuPopupRef, ILuPopupRef, ILuPopupRefFactory } from '@lucca-front/ng/popup';
+import { LuTranslation } from '@lucca-front/ng/core';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { ComponentType } from '@angular/cdk/portal';
+import * as i1 from '@angular/cdk/overlay';
+import { Overlay, ComponentType as ComponentType$1 } from '@angular/cdk/overlay';
+import * as i2 from '@angular/cdk/dialog';
+import { LuDialogService } from '@lucca-front/ng/dialog';
+
+type LuModalMode = 'modal' | 'sidepanel';
+interface LuModalClasses {
+    panel: string;
+    panelContainer: string;
+    panelInner: string;
+    overlayPane?: string;
+}
+declare const luModalClasses: Record<LuModalMode, LuModalClasses>;
+type LuModalModeWithPosition = {
+    mode?: 'modal';
+    position: undefined | 'center';
+} | {
+    mode: 'sidepanel';
+    position: 'left' | 'right';
+};
+type LuModalConfig = ILuPopupConfig & LuModalModeWithPosition & {
+    changeDetection: ChangeDetectionStrategy;
+};
+
+declare const luDefaultModalConfig: LuModalConfig;
+declare const luDefaultSidepanelConfig: LuModalConfig;
+
+declare const LU_MODAL_TRANSLATIONS: InjectionToken<LuTranslation<ILuModalLabel>>;
+interface ILuModalLabel {
+    submit: string;
+    cancel: string;
+    close: string;
+}
+declare const luModalTranslations: LuTranslation<ILuModalLabel>;
+
+interface ILuModalContent<T = unknown> {
+    title: string | Observable<string>;
+    submitAction?: () => T | Observable<T>;
+    submitLabel?: string | Observable<string>;
+    submitPalette?: string;
+    submitDisabled?: boolean | Observable<boolean>;
+    submitCounter?: number | Observable<number>;
+    cancelLabel?: string | Observable<string>;
+}
+type LuModalContentResult<T extends ILuModalContent> = T extends ILuModalContent<infer R> & {
+    submitAction: unknown;
+} ? R : never;
+
+interface ILuModalRef<D = unknown, R = unknown> extends ILuPopupRef<D, R> {
+    mode: LuModalMode;
+    modalClasses: LuModalClasses;
+}
+interface IModalRefFactory {
+    forge<T extends ILuModalContent, C extends LuModalConfig, D>(component: ComponentType<T>, config: C): ILuModalRef<D, LuModalContentResult<T>>;
+}
+declare abstract class ALuModalRef<T extends ILuModalContent = ILuModalContent, D = unknown, R = unknown, C extends LuModalConfig = LuModalConfig> extends ALuPopupRef<T, D, R, C> implements ILuModalRef<D, R> {
+    get mode(): LuModalMode;
+    get modalClasses(): LuModalClasses;
+}
+
+declare abstract class ALuModalPanelComponent<T extends ILuModalContent> implements OnDestroy, DoCheck {
+    protected _ref: ALuModalRef<T>;
+    protected _containerRef: ViewContainerRef;
+    protected _componentInstance: ILuModalContent;
+    protected doCheck$: ReplaySubject<void>;
+    intl: ILuModalLabel;
+    protected title$: Observable<string>;
+    protected submitLabel$: Observable<string>;
+    protected cancelLabel$: Observable<string>;
+    protected submitCounter$: Observable<number>;
+    protected submitDisabled$: Observable<boolean>;
+    protected hasSubmitCounter$: Observable<boolean>;
+    protected closeLabel: string;
+    get isSubmitHidden(): boolean;
+    get submitPalette(): string;
+    submitClass$: Subject<unknown>;
+    error$: Subject<unknown>;
+    readonly modalId: number;
+    private _subs;
+    modalClasses: LuModalClasses;
+    constructor(_ref: ALuModalRef<T>, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2);
+    ngDoCheck(): void;
+    attachInnerComponent(componentType: Type<T>, injector: Injector): i0.ComponentRef<T>;
+    ngOnDestroy(): void;
+    dismiss(): void;
+    submit(): void;
+    private listenComponentValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ALuModalPanelComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuModalPanelComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+declare class LuModalPanelComponent<T extends ILuModalContent = ILuModalContent> extends ALuModalPanelComponent<T> {
+    class: boolean;
+    constructor(_ref: ALuModalRef<T>, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalPanelComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuModalPanelComponent<any>, "lu-modal-panel", never, {}, {}, never, never, true, never>;
+}
+declare class LuModalPanelComponentDefaultCD<T extends ILuModalContent = ILuModalContent> extends ALuModalPanelComponent<T> {
+    class: boolean;
+    constructor(_ref: ALuModalRef<T>, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalPanelComponentDefaultCD<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuModalPanelComponentDefaultCD<any>, "lu-modal-panel-default", never, {}, {}, never, never, true, never>;
+}
+
+declare class LuModalRef<T extends ILuModalContent = ILuModalContent, D = unknown, R = unknown, C extends LuModalConfig = LuModalConfig> extends ALuModalRef<T, D, R, C> implements ILuModalRef<D, R> {
+    protected _overlay: Overlay;
+    protected _injector: Injector;
+    protected _component: ComponentType$1<T>;
+    protected _config: C;
+    protected _applicationRef: ApplicationRef;
+    protected _containerRef: ComponentRef<ALuModalPanelComponent<T>>;
+    constructor(_overlay: Overlay, _injector: Injector, _component: ComponentType$1<T>, _config: C, _applicationRef: ApplicationRef);
+    protected _openPopup(data?: D): void;
+    protected _closePopup(): void;
+    protected _getOverlayPanelClasses(): string[];
+}
+declare class LuModalRefFactory implements ILuPopupRefFactory<ILuModalContent, LuModalConfig> {
+    protected _overlay: Overlay;
+    protected _injector: Injector;
+    protected _applicationRef: ApplicationRef;
+    constructor(_overlay: Overlay, _injector: Injector);
+    forge<T extends ILuModalContent, C extends LuModalConfig, D, R>(component: ComponentType$1<T>, config: C): LuModalRef<T, D, R, LuModalConfig>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalRefFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuModalRefFactory>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Provide LuModal.
+ * Note that OverlayModule should be imported in one of the EnvironmentInjectors (AppModule, lazy-loaded route) using `providers: [importProvidersFrom(OverlayModule)]`.
  */
-/// <amd-module name="@lucca-front/ng/modal" />
-export * from './public-api';
+declare function provideLuModal(): Provider[];
+declare class LuModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuModalModule, never, [typeof i1.OverlayModule, typeof i2.DialogModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuModalModule>;
+}
+
+declare class LuModal {
+    protected _factory: IModalRefFactory;
+    protected _config: LuModalConfig;
+    protected luDialogService: LuDialogService;
+    open<T extends ILuModalContent, D>(component: ComponentType<T>, data?: D, config?: Partial<LuModalConfig>): ILuModalRef<D, LuModalContentResult<T>>;
+    legacyOpen<T extends ILuModalContent, D>(component: ComponentType<T>, data?: D, config?: Partial<LuModalConfig>): ILuModalRef<D, LuModalContentResult<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuModal, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuModal>;
+}
+
+/** Injection token that can be used to access the data that was passed in to a dialog. */
+declare const LU_MODAL_DATA: InjectionToken<unknown>;
+declare const LU_MODAL_CONFIG: InjectionToken<LuModalConfig>;
+declare const LU_MODAL_REF_FACTORY: InjectionToken<IModalRefFactory>;
+
+declare function setAriaHiddenOnApplicationRoot(applicationRef: ApplicationRef, hidden: boolean): void;
+
+export { ALuModalPanelComponent, ALuModalRef, LU_MODAL_CONFIG, LU_MODAL_DATA, LU_MODAL_REF_FACTORY, LU_MODAL_TRANSLATIONS, LuModal, LuModalModule, LuModalPanelComponent, LuModalPanelComponentDefaultCD, LuModalRefFactory, luDefaultModalConfig, luDefaultSidepanelConfig, luModalClasses, luModalTranslations, provideLuModal, setAriaHiddenOnApplicationRoot };
+export type { ILuModalContent, ILuModalLabel, ILuModalRef, IModalRefFactory, LuModalClasses, LuModalConfig, LuModalContentResult, LuModalMode };

package/multi-select/index.d.ts

@@ -1,5 +1,224 @@
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken, ChangeDetectorRef, ElementRef, Injector, ViewContainerRef, OnDestroy, OnInit, Type, TemplateRef, DestroyRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { LuTranslation } from '@lucca-front/ng/core';
+import { ControlValueAccessor, AbstractControl, ValidationErrors } from '@angular/forms';
+import { LuOptionComparer, LuSelectPanelRef, ALuSelectInputComponent, LuOptionContext, ILuOptionContext } from '@lucca-front/ng/core-select';
+import { Overlay, OverlayPositionBuilder, ScrollStrategyOptions, OverlayConfig, ConnectedPosition } from '@angular/cdk/overlay';
+import * as i1 from '@lucca-front/ng/form-field';
+import { LuOptionComparer as LuOptionComparer$1 } 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 ɵIsSelectedStrategy<TOption> {
+    abstract isSelected(option: TOption, selectedOptions: TOption[], optionComparer: LuOptionComparer<TOption>): boolean;
+    abstract isGroupSelected(options: TOption[], notSelectedOptions: TOption[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵIsSelectedStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵIsSelectedStrategy<any>>;
+}
+
+interface LuMultiSelectWithSelectAllContext {
+    setSelectAll(value: boolean): void;
+    mode: Signal<LuMultiSelectionMode>;
+    values: Signal<unknown[]>;
+    displayerLabel: Signal<string>;
+    totalCount: Signal<number>;
+}
+
+declare class LuMultiSelectWithSelectAllDirective<TValue> extends ɵIsSelectedStrategy<TValue> implements LuMultiSelectWithSelectAllContext {
+    #private;
+    readonly displayerLabel: i0.InputSignal<string>;
+    readonly mode: i0.Signal<"include" | "exclude" | "none" | "all">;
+    readonly values: i0.Signal<TValue[]>;
+    readonly totalCount: i0.Signal<number>;
+    constructor();
+    setSelectAll(selectAll: boolean): void;
+    isSelected(option: TValue, selectedOptions: TValue[], optionComparer: LuOptionComparer$1<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 const LU_MULTI_SELECT_TRANSLATIONS: InjectionToken<LuTranslation<ILuMultiSelectLabel>>;
+interface ILuMultiSelectLabel {
+    placeholder: string;
+    search: string;
+    clear: string;
+    clearSearch: string;
+    emptyResults: string;
+    emptySelection: string;
+    expand: string;
+    reduce: string;
+    selectAll: string;
+    unselectAll: string;
+    loading: string;
+}
+declare const luMultiSelectTranslations: LuTranslation<ILuMultiSelectLabel>;
+
+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: ILuMultiSelectLabel;
+    showColon: false;
+    valuesTpl: i0.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<T[]>>>;
+    maxValuesShown: number;
+    keepSearchAfterSelection: boolean;
+    filterPillLabelPlural: string;
+    get filterPillClass(): boolean;
+    hideCombobox: i0.Signal<boolean>;
+    filterPillPanelAnchorRef: i0.Signal<ViewContainerRef>;
+    isFilterPillEmpty: i0.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>;
+    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, { "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 class LuMultiSelectCounterDisplayerComponent<T> implements OnInit {
+    select: LuMultiSelectInputComponent<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 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 LuMultiSelectDefaultDisplayerComponent<T> implements OnInit {
+    select: LuMultiSelectInputComponent<T>;
+    intl: 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, {}, {}, never, never, true, never>;
+}
+
+declare class LuMultiSelectDisplayerInputDirective<T> implements OnInit {
+    #private;
+    select: LuMultiSelectInputComponent<T>;
+    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;
+    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>>;
 /**
- * Generated bundle index. Do not edit.
+ * 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);
+ * ```
  */
-/// <amd-module name="@lucca-front/ng/multi-select" />
-export * from './public-api';
+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, LuMultiSelectCounterDisplayerComponent, LuMultiSelectDefaultDisplayerComponent, LuMultiSelectDisplayerInputDirective, LuMultiSelectInputComponent, LuMultiSelectWithSelectAllDirective, LuMultiSelectionValidators, luMultiSelectDisplayerTranslations, luMultiSelectTranslations, selectionToOptions, selectionToQueryParams };
+export type { ILuMultiSelectDisplayerLabel, ILuMultiSelectLabel, LuMultiSelection, LuMultiSelectionMode };

package/new-badge/index.d.ts

@@ -1,5 +1,10 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/new-badge" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+declare class NewBadgeComponent {
+    label: string;
+    newBadge: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewBadgeComponent, "lu-new-badge", never, { "label": { "alias": "label"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+export { NewBadgeComponent };

package/number/index.d.ts

@@ -1,5 +1,18 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/number" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+
+declare class LuNumberPipe implements PipeTransform {
+    protected locale: string;
+    constructor(locale: string);
+    transform(number: number, precision?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LuNumberPipe, "luNumber", true>;
+}
+
+declare class LuNumberModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuNumberModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuNumberModule, never, [typeof LuNumberPipe], [typeof LuNumberPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuNumberModule>;
+}
+
+export { LuNumberModule, LuNumberPipe };