@lucca-front/ng 21.0.0-rc.3 → 21.0.0-rc.4

package/plg-push/index.d.ts

@@ -1,4 +1,4 @@
-import * as _angular_core from '@angular/core';
+import * as i0 from '@angular/core';
 
 interface LuPlgPushLabel {
     close: string;
@@ -6,14 +6,16 @@ interface LuPlgPushLabel {
 
 declare class PLGPushComponent {
     protected intl: LuPlgPushLabel;
-    readonly heading: _angular_core.InputSignal<string>;
-    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    heading: string;
+    removable: boolean;
     /**
      * Is the callout removed? Works with two way binding too.
      */
-    readonly removed: _angular_core.ModelSignal<boolean>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PLGPushComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PLGPushComponent, "lu-plg-push", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "removed": { "alias": "removed"; "required": false; "isSignal": true; }; }, { "removed": "removedChange"; }, never, ["*"], true, never>;
+    removed: i0.ModelSignal<boolean>;
+    get hiddenAttr(): 'hidden' | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PLGPushComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PLGPushComponent, "lu-plg-push", never, { "heading": { "alias": "heading"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "removed": { "alias": "removed"; "required": false; "isSignal": true; }; }, { "removed": "removedChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_removable: unknown;
 }
 
 export { PLGPushComponent };

package/scroll/index.d.ts

@@ -1,41 +1,43 @@
-import * as _angular_core from '@angular/core';
-import { OutputEmitterRef, OnInit, ElementRef } from '@angular/core';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
 
 interface ILuScrollable {
-    onScroll: OutputEmitterRef<Event>;
-    onScrollTop: OutputEmitterRef<Event>;
-    onScrollBottom: OutputEmitterRef<Event>;
-    onScrollLeft: OutputEmitterRef<Event>;
-    onScrollRight: OutputEmitterRef<Event>;
+    onScroll: Observable<Event>;
+    onScrollTop: Observable<Event>;
+    onScrollBottom: Observable<Event>;
+    onScrollLeft: Observable<Event>;
+    onScrollRight: Observable<Event>;
 }
 
 /**
  * emits on scroll events
  */
 declare class LuScrollDirective implements ILuScrollable, OnInit {
-    #private;
     protected _elementRef: ElementRef<HTMLElement>;
-    readonly debounceTime: _angular_core.InputSignal<number>;
-    readonly onScroll: _angular_core.OutputEmitterRef<Event>;
-    readonly onScrollTop: _angular_core.OutputEmitterRef<Event>;
-    readonly onScrollBottom: _angular_core.OutputEmitterRef<Event>;
-    readonly onScrollLeft: _angular_core.OutputEmitterRef<Event>;
-    readonly onScrollRight: _angular_core.OutputEmitterRef<Event>;
-    scroll(event: Event): void;
+    debounceTime: number;
+    onScroll: EventEmitter<Event>;
+    onScrollTop: EventEmitter<Event>;
+    onScrollBottom: EventEmitter<Event>;
+    onScrollLeft: EventEmitter<Event>;
+    onScrollRight: EventEmitter<Event>;
+    private scrollSubject;
+    private scroll$;
+    _scroll($event: Event): void;
     ngOnInit(): void;
     private emitScrollEvents;
     constructor(_elementRef: ElementRef<HTMLElement>);
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuScrollDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuScrollDirective, "[luScroll]", ["luScroll"], { "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; }, { "onScroll": "onScroll"; "onScrollTop": "onScrollTop"; "onScrollBottom": "onScrollBottom"; "onScrollLeft": "onScrollLeft"; "onScrollRight": "onScrollRight"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuScrollDirective, "[luScroll]", ["luScroll"], { "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "onScroll": "onScroll"; "onScrollTop": "onScrollTop"; "onScrollBottom": "onScrollBottom"; "onScrollLeft": "onScrollLeft"; "onScrollRight": "onScrollRight"; }, never, never, true, never>;
 }
 
 /**
  * @deprecated use `LuScrollDirective` instead
  */
 declare class LuScrollModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuScrollModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LuScrollModule, never, [typeof LuScrollDirective], [typeof LuScrollDirective]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LuScrollModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuScrollModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuScrollModule, never, [typeof LuScrollDirective], [typeof LuScrollDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuScrollModule>;
 }
 
 export { LuScrollDirective, LuScrollModule };

package/skeleton/index.d.ts

@@ -1,21 +1,23 @@
 import * as _angular_core from '@angular/core';
 
 declare class SkeletonButtonComponent {
-    readonly dark: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly size: _angular_core.InputSignal<"XS" | "S" | "M">;
+    dark: boolean;
+    size: 'XS' | 'S' | 'M';
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonButtonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonButtonComponent, "lu-skeleton-button", never, { "dark": { "alias": "dark"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonButtonComponent, "lu-skeleton-button", never, { "dark": { "alias": "dark"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_dark: unknown;
 }
 
 declare class SkeletonDataTableComponent {
-    readonly dataTableBodyOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly cols: _angular_core.InputSignal<number>;
-    readonly colsNumber: _angular_core.Signal<unknown[]>;
-    readonly rows: _angular_core.InputSignal<number>;
-    readonly rowsNumber: _angular_core.Signal<unknown[]>;
-    readonly randomPercent: string;
+    dataTableBodyOnly: boolean;
+    cols: _angular_core.InputSignal<number>;
+    colsNumber: _angular_core.Signal<unknown[]>;
+    rows: _angular_core.InputSignal<number>;
+    rowsNumber: _angular_core.Signal<unknown[]>;
+    getRandomPercent: (min?: number, max?: number) => string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonDataTableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonDataTableComponent, "lu-skeleton-data-table", never, { "dataTableBodyOnly": { "alias": "dataTableBodyOnly"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonDataTableComponent, "lu-skeleton-data-table", never, { "dataTableBodyOnly": { "alias": "dataTableBodyOnly"; "required": false; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_dataTableBodyOnly: unknown;
 }
 
 declare class SkeletonFieldComponent {
@@ -23,37 +25,40 @@ declare class SkeletonFieldComponent {
     readonly hiddenLabel: _angular_core.InputSignalWithTransform<boolean, boolean | "false" | "true">;
     readonly rows: _angular_core.InputSignalWithTransform<number, number | `${number}`>;
     readonly lines: _angular_core.Signal<unknown[]>;
-    randomPercent(min?: number, max?: number): string;
+    readonly getRandomPercent: (min?: number, max?: number) => number;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonFieldComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonFieldComponent, "lu-skeleton-field", never, { "dark": { "alias": "dark"; "required": false; "isSignal": true; }; "hiddenLabel": { "alias": "hiddenLabel"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class SkeletonHeaderComponent {
-    readonly dark: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    dark: boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonHeaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonHeaderComponent, "lu-skeleton-header", never, { "dark": { "alias": "dark"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonHeaderComponent, "lu-skeleton-header", never, { "dark": { "alias": "dark"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_dark: unknown;
 }
 
 declare class SkeletonIndexTableComponent {
-    readonly tableBodyOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly cols: _angular_core.InputSignal<number>;
-    readonly colsNumber: _angular_core.Signal<unknown[]>;
-    readonly rows: _angular_core.InputSignal<number>;
-    readonly rowsNumber: _angular_core.Signal<unknown[]>;
-    readonly randomPercent: string;
+    tableBodyOnly: boolean;
+    cols: _angular_core.InputSignal<number>;
+    colsNumber: _angular_core.Signal<unknown[]>;
+    rows: _angular_core.InputSignal<number>;
+    rowsNumber: _angular_core.Signal<unknown[]>;
+    getRandomPercent: (min?: number, max?: number) => string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonIndexTableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonIndexTableComponent, "lu-skeleton-index-table", never, { "tableBodyOnly": { "alias": "tableBodyOnly"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonIndexTableComponent, "lu-skeleton-index-table", never, { "tableBodyOnly": { "alias": "tableBodyOnly"; "required": false; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_tableBodyOnly: unknown;
 }
 
 declare class SkeletonTableComponent {
-    readonly tableBodyOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly cols: _angular_core.InputSignal<number>;
-    readonly colsNumber: _angular_core.Signal<unknown[]>;
-    readonly rows: _angular_core.InputSignal<number>;
-    readonly rowsNumber: _angular_core.Signal<unknown[]>;
-    readonly randomPercent: string;
+    tableBodyOnly: boolean;
+    cols: _angular_core.InputSignal<number>;
+    colsNumber: _angular_core.Signal<unknown[]>;
+    rows: _angular_core.InputSignal<number>;
+    rowsNumber: _angular_core.Signal<unknown[]>;
+    getRandomPercent: (min?: number, max?: number) => string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonTableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonTableComponent, "lu-skeleton-table", never, { "tableBodyOnly": { "alias": "tableBodyOnly"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonTableComponent, "lu-skeleton-table", never, { "tableBodyOnly": { "alias": "tableBodyOnly"; "required": false; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_tableBodyOnly: unknown;
 }
 
 export { SkeletonButtonComponent, SkeletonDataTableComponent, SkeletonFieldComponent, SkeletonHeaderComponent, SkeletonIndexTableComponent, SkeletonTableComponent };

package/tag/index.d.ts

@@ -3,39 +3,37 @@ import { LuccaIcon } from '@lucca-front/icons';
 import { Palette, DecorativePalette } from '@lucca-front/ng/core';
 
 declare class TagComponent {
+    withEllipsis: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    label: string;
     /**
-     * Which text should the tag be? Defaults to medium
+     * Which size should the callout be? Defaults to medium
      */
-    readonly label: _angular_core.InputSignal<string>;
+    size: 'S' | 'M' | 'L';
     /**
-     * Which size should the tag be? Defaults to medium
-     */
-    readonly size: _angular_core.InputSignal<"S" | "M" | "L">;
-    /**
-     * Which palette should be used for the entire tag.
+     * Which palette should be used for the entire callout.
      * Defaults to none (inherits parent palette)
      */
-    readonly palette: _angular_core.InputSignal<Palette | DecorativePalette>;
+    palette: Palette | DecorativePalette;
     /**
      * Should display be outlined?
      */
-    readonly outlined: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    outlined: boolean;
     /**
      * For routerLink usage
      */
-    readonly link: _angular_core.InputSignal<string>;
+    link: string;
     /**
-     * Which icon should we display in the tag if any?
+     * Which icon should we display in the callout if any?
      * Defaults to no icon.
      */
-    readonly icon: _angular_core.InputSignal<LuccaIcon>;
-    readonly withEllipsis: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly AI: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly tagClasses: _angular_core.Signal<{
+    icon: LuccaIcon | undefined;
+    AI: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    get tagClasses(): {
         [x: string]: boolean;
-    }>;
+    };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "lu-tag", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "withEllipsis": { "alias": "withEllipsis"; "required": false; "isSignal": true; }; "AI": { "alias": "AI"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "lu-tag", never, { "withEllipsis": { "alias": "withEllipsis"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; }; "size": { "alias": "size"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "outlined": { "alias": "outlined"; "required": false; }; "link": { "alias": "link"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "AI": { "alias": "AI"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_outlined: unknown;
 }
 
 export { TagComponent };

package/time/index.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, ModelSignal, ElementRef } from '@angular/core';
+import { InjectionToken, ModelSignal, EventEmitter, ElementRef } from '@angular/core';
 import { LuTranslation } from '@lucca-front/ng/core';
 import { ControlValueAccessor } from '@angular/forms';
 
@@ -28,10 +28,10 @@ declare class TimePickerPartComponent {
     hideValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     focused: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    prevRequest: _angular_core.OutputEmitterRef<void>;
-    nextRequest: _angular_core.OutputEmitterRef<void>;
-    inputControlClick: _angular_core.OutputEmitterRef<PickerControlDirection>;
-    touched: _angular_core.OutputEmitterRef<void>;
+    prevRequest: EventEmitter<void>;
+    nextRequest: EventEmitter<void>;
+    inputControlClick: EventEmitter<PickerControlDirection>;
+    touched: EventEmitter<void>;
     timePickerInput?: ElementRef<HTMLInputElement>;
     valueLabel: _angular_core.Signal<string | number>;
     protected inputId: string;

package/toast/index.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, OnDestroy } from '@angular/core';
 import { LuTranslation, PortalContent } from '@lucca-front/ng/core';
 import * as rxjs from 'rxjs';
-import { Observable, BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
 
 declare const LU_TOAST_TRANSLATIONS: InjectionToken<LuTranslation<ILuToastLabel>>;
 interface ILuToastLabel {
@@ -33,20 +33,33 @@ interface LuToast extends LuToastInput {
     id: string;
 }
 
-declare class LuToastsComponent {
-    #private;
-    readonly bottom: i0.InputSignal<boolean>;
-    readonly sources: i0.InputSignal<Observable<LuToastInput>[]>;
-    constructor();
-    readonly toasts$: rxjs.BehaviorSubject<LuToast[]>;
-    readonly intl: ILuToastLabel;
-    readonly iconClassByToastType: Record<LuToastType, string>;
-    readonly paletteClassByToastType: Record<LuToastType, string>;
+declare class LuToastsService {
+    toasts$: BehaviorSubject<LuToast[]>;
+    addToast(toastInput: LuToastInput): LuToast;
+    removeToast(toast: LuToast): void;
+    isOnlyDismissibleManually({ duration }: LuToastInput): boolean;
+    private getToast;
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuToastsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuToastsService>;
+}
+
+declare class LuToastsComponent implements OnDestroy {
+    private toastsService;
+    bottom: boolean;
+    set sources(sources: Array<Observable<LuToastInput>>);
+    toasts$: rxjs.BehaviorSubject<LuToast[]>;
+    private destroy$;
+    intl: ILuToastLabel;
+    constructor(toastsService: LuToastsService);
+    ngOnDestroy(): void;
+    iconClassByToastType: Record<LuToastType, string>;
+    paletteClassByToastType: Record<LuToastType, string>;
     isStringPortalContent(message: PortalContent): message is string;
     removeToast(toast: LuToast): void;
     isOnlyDismissibleManually(toast: LuToast): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<LuToastsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LuToastsComponent, "lu-toasts", never, { "bottom": { "alias": "bottom"; "required": false; "isSignal": true; }; "sources": { "alias": "sources"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuToastsComponent, "lu-toasts", never, { "bottom": { "alias": "bottom"; "required": false; }; "sources": { "alias": "sources"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -58,16 +71,5 @@ declare class LuToastsModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<LuToastsModule>;
 }
 
-declare class LuToastsService {
-    toasts$: BehaviorSubject<LuToast[]>;
-    addToast(toastInput: LuToastInput): LuToast;
-    removeToast(toast: LuToast): void;
-    isOnlyDismissibleManually({ duration }: LuToastInput): boolean;
-    private getToast;
-    private generateId;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LuToastsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LuToastsService>;
-}
-
 export { LU_TOAST_TRANSLATIONS, LuToastsComponent, LuToastsModule, LuToastsService, defaultToastDuration, luToastTranslations };
 export type { ILuToastLabel, LuToast, LuToastInput, LuToastType };

package/tooltip/index.d.ts

@@ -1,8 +1,8 @@
 import { AnimationTriggerMetadata } from '@angular/animations';
-import * as _angular_core from '@angular/core';
-import { DestroyRef, OnDestroy } from '@angular/core';
 import * as i2 from '@angular/cdk/overlay';
 import { HorizontalConnectionPos, VerticalConnectionPos, FlexibleConnectedPositionStrategyOrigin, OverlayRef } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { DestroyRef, Signal, AfterContentInit, OnDestroy } from '@angular/core';
 import { SafeHtml } from '@angular/platform-browser';
 import { Subject, Observable } from 'rxjs';
 import { LuPopoverPosition } from '@lucca-front/ng/popover';
@@ -10,49 +10,54 @@ import { LuPopoverPosition } from '@lucca-front/ng/popover';
 declare const luTransformTooltip: AnimationTriggerMetadata;
 
 declare class LuTooltipPanelComponent {
-    readonly destroyRef: DestroyRef;
-    readonly mouseEnter$: Subject<void>;
-    readonly mouseLeave$: Subject<void>;
-    readonly content: _angular_core.WritableSignal<string | SafeHtml>;
-    readonly id: _angular_core.WritableSignal<string>;
-    readonly contentPositionClasses: _angular_core.WritableSignal<Record<string, boolean>>;
+    destroyRef: DestroyRef;
+    mouseEnter$: Subject<void>;
+    mouseEnter(): void;
+    mouseLeave$: Subject<void>;
+    mouseLeave(): void;
+    content: Signal<string | SafeHtml>;
+    id: string;
+    contentPositionClasses: Record<string, boolean>;
     setPanelPosition(posX: HorizontalConnectionPos, posY: VerticalConnectionPos): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuTooltipPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuTooltipPanelComponent, "lu-tooltip-panel", never, {}, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuTooltipPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuTooltipPanelComponent, "lu-tooltip-panel", never, {}, {}, never, never, true, never>;
 }
 
 /**
  * @deprecated use `LuTooltipPanelComponent` instead
  */
 declare class LuTooltipPanelModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuTooltipPanelModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LuTooltipPanelModule, never, [typeof LuTooltipPanelComponent], [typeof LuTooltipPanelComponent]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LuTooltipPanelModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuTooltipPanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTooltipPanelModule, never, [typeof LuTooltipPanelComponent], [typeof LuTooltipPanelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuTooltipPanelModule>;
 }
 
-declare class LuTooltipTriggerDirective implements OnDestroy {
+declare class LuTooltipTriggerDirective implements AfterContentInit, OnDestroy {
     #private;
-    readonly luTooltip: _angular_core.InputSignal<string | SafeHtml>;
-    readonly luTooltipEnterDelay: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly luTooltipLeaveDelay: _angular_core.InputSignalWithTransform<number, unknown>;
-    readonly luTooltipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly luTooltipOnlyForDisplay: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly luTooltipPosition: _angular_core.InputSignal<LuPopoverPosition>;
-    readonly luTooltipWhenEllipsis: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly luTooltipAnchor: _angular_core.InputSignal<FlexibleConnectedPositionStrategyOrigin>;
-    readonly resize$: Observable<void>;
+    luTooltip: i0.InputSignal<string | SafeHtml>;
+    set luTooltipEnterDelay(delay: number);
+    set luTooltipLeaveDelay(delay: number);
+    luTooltipDisabled: i0.InputSignalWithTransform<boolean, unknown>;
+    luTooltipOnlyForDisplay: boolean;
+    luTooltipPosition: LuPopoverPosition;
+    luTooltipWhenEllipsis: i0.InputSignalWithTransform<boolean, unknown>;
+    luTooltipAnchor: i0.InputSignal<FlexibleConnectedPositionStrategyOrigin>;
+    resize$: Observable<void>;
+    open$: Subject<void>;
+    close$: Subject<void>;
     onMouseEnter(): void;
     onMouseLeave(): void;
     onFocus(): void;
     onBlur(): void;
-    readonly id: _angular_core.WritableSignal<string>;
-    readonly ariaDescribedBy: _angular_core.Signal<string>;
+    _id: string;
+    get ariaDescribedBy(): string;
     overlayRef?: OverlayRef;
     constructor();
     ngOnDestroy(): void;
     private openTooltip;
     private closeTooltip;
     private setAccessibilityProperties;
+    ngAfterContentInit(): void;
     private runOutsideZoneJS;
     /**********************
      *
@@ -62,26 +67,29 @@ declare class LuTooltipTriggerDirective implements OnDestroy {
     private legacyPositionBuilder;
     private invertVerticalPos;
     private invertHorizontalPos;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuTooltipTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuTooltipTriggerDirective, "[luTooltip]", ["luTooltip"], { "luTooltip": { "alias": "luTooltip"; "required": false; "isSignal": true; }; "luTooltipEnterDelay": { "alias": "luTooltipEnterDelay"; "required": false; "isSignal": true; }; "luTooltipLeaveDelay": { "alias": "luTooltipLeaveDelay"; "required": false; "isSignal": true; }; "luTooltipDisabled": { "alias": "luTooltipDisabled"; "required": false; "isSignal": true; }; "luTooltipOnlyForDisplay": { "alias": "luTooltipOnlyForDisplay"; "required": false; "isSignal": true; }; "luTooltipPosition": { "alias": "luTooltipPosition"; "required": false; "isSignal": true; }; "luTooltipWhenEllipsis": { "alias": "luTooltipWhenEllipsis"; "required": false; "isSignal": true; }; "luTooltipAnchor": { "alias": "luTooltipAnchor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuTooltipTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuTooltipTriggerDirective, "[luTooltip]", ["luTooltip"], { "luTooltip": { "alias": "luTooltip"; "required": false; "isSignal": true; }; "luTooltipEnterDelay": { "alias": "luTooltipEnterDelay"; "required": false; }; "luTooltipLeaveDelay": { "alias": "luTooltipLeaveDelay"; "required": false; }; "luTooltipDisabled": { "alias": "luTooltipDisabled"; "required": false; "isSignal": true; }; "luTooltipOnlyForDisplay": { "alias": "luTooltipOnlyForDisplay"; "required": false; }; "luTooltipPosition": { "alias": "luTooltipPosition"; "required": false; }; "luTooltipWhenEllipsis": { "alias": "luTooltipWhenEllipsis"; "required": false; "isSignal": true; }; "luTooltipAnchor": { "alias": "luTooltipAnchor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_luTooltipEnterDelay: unknown;
+    static ngAcceptInputType_luTooltipLeaveDelay: unknown;
+    static ngAcceptInputType_luTooltipOnlyForDisplay: unknown;
 }
 
 /**
  * @deprecated use `LuTooltipTriggerDirective, OverlayModule` instead
  */
 declare class LuTooltipTriggerModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuTooltipTriggerModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LuTooltipTriggerModule, never, [typeof LuTooltipTriggerDirective, typeof i2.OverlayModule], [typeof LuTooltipTriggerDirective]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LuTooltipTriggerModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuTooltipTriggerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTooltipTriggerModule, never, [typeof LuTooltipTriggerDirective, typeof i2.OverlayModule], [typeof LuTooltipTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuTooltipTriggerModule>;
 }
 
 /**
  * @deprecated use `LuTooltipTriggerDirective, OverlayModule, LuTooltipPanelComponent` instead
  */
 declare class LuTooltipModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuTooltipModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LuTooltipModule, never, [typeof LuTooltipTriggerModule, typeof LuTooltipPanelModule], [typeof LuTooltipTriggerModule, typeof LuTooltipPanelModule]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LuTooltipModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuTooltipModule, never, [typeof LuTooltipTriggerModule, typeof LuTooltipPanelModule], [typeof LuTooltipTriggerModule, typeof LuTooltipPanelModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuTooltipModule>;
 }
 
 export { LuTooltipModule, LuTooltipPanelComponent, LuTooltipPanelModule, LuTooltipTriggerDirective, LuTooltipTriggerModule, luTransformTooltip };

package/user/index.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, PipeTransform, AfterViewInit, ChangeDetectorRef, ElementRef, ViewContainerRef, Renderer2, OnInit, OnDestroy, TemplateRef } from '@angular/core';
+import { InjectionToken, PipeTransform, OnChanges, AfterViewInit, ChangeDetectorRef, ElementRef, ViewContainerRef, Renderer2, OnInit, OnDestroy, TemplateRef } from '@angular/core';
 import { EnumValue, LuTranslation, ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber, ILuOnCloseSubscriber } from '@lucca-front/ng/core';
 import { Overlay } from '@angular/cdk/overlay';
 import { ControlValueAccessor, FormGroup } from '@angular/forms';
@@ -91,27 +91,33 @@ interface LuUserTileUserInput {
  */
 declare class LuUserTileComponent {
     #private;
+    displayPictureFormat: LuDisplayInitials;
+    private _user;
     /**
      * LuUserTileUserInput to display.
      */
-    readonly user: i0.InputSignal<LuUserTileUserInput>;
+    set user(user: LuUserTileUserInput);
+    get user(): LuUserTileUserInput;
+    private _displayFormat;
     /**
      * User Display format.
      * It is set to 'LU_DEFAULT_DISPLAY_POLICY' by default
      */
-    readonly displayFormat: i0.InputSignal<LuDisplayFormat>;
+    set displayFormat(displayFormat: LuDisplayFormat);
+    get displayFormat(): LuDisplayFormat;
+    private _role;
     /**
      * LuUserTileUserInput role to display
      */
-    readonly role: i0.InputSignal<string>;
+    set role(role: string);
+    get role(): string;
     /**
      * Which size should the user tile be? Defaults to medium
      */
-    readonly size: i0.InputSignal<"L" | "XS" | "S" | "M">;
-    readonly displayPictureFormat: i0.Signal<LuDisplayInitials>;
+    size: i0.InputSignal<"L" | "XS" | "S" | "M">;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<LuUserTileComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LuUserTileComponent, "lu-user-tile", never, { "user": { "alias": "user"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuUserTileComponent, "lu-user-tile", never, { "user": { "alias": "user"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "role": { "alias": "role"; "required": false; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -134,32 +140,37 @@ interface LuUserPictureUserInput {
 /**
  * Displays user's picture or a placeholder with his/her initials and random bg color'
  */
-declare class LuUserPictureComponent {
+declare class LuUserPictureComponent implements OnChanges {
     /**
      * User Display format.
      * It is set to 'LU_DEFAULT_DISPLAY_POLICY' by default
      */
-    readonly displayFormat: i0.InputSignal<LuDisplayInitials>;
-    readonly user: i0.InputSignal<LuUserPictureUserInput>;
-    readonly AI: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly size: i0.InputSignal<"L" | "XS" | "S" | "M" | "XL" | "XXL" | "XXXL">;
+    displayFormat: LuDisplayInitials;
     /**
      * Image loading attribute
      * It is set to 'lazy' by default
      *
      * (more info: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#loading)
      */
-    readonly imageLoadingAttribute: i0.InputSignal<"eager" | "lazy">;
-    readonly initials: i0.Signal<string>;
-    readonly modSize: i0.Signal<string>;
+    imageLoadingAttribute: HTMLImageElement['loading'];
+    /**
+     * UserPictureUserInput whose picture you want to display.
+     */
+    private _user;
+    set user(user: LuUserPictureUserInput);
+    AI: i0.InputSignalWithTransform<boolean, unknown>;
+    size: i0.InputSignal<"L" | "XS" | "S" | "M" | "XL" | "XXL" | "XXXL">;
+    get user(): LuUserPictureUserInput;
+    initials: string;
     hasPicture: boolean;
     pictureHref: string;
     style: {};
-    constructor();
+    modSize: i0.Signal<string>;
+    ngOnChanges(): void;
     pictureError(): void;
     private getNameHue;
     static ɵfac: i0.ɵɵFactoryDeclaration<LuUserPictureComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LuUserPictureComponent, "lu-user-picture", never, { "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "user": { "alias": "user"; "required": false; "isSignal": true; }; "AI": { "alias": "AI"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "imageLoadingAttribute": { "alias": "imageLoadingAttribute"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuUserPictureComponent, "lu-user-picture", never, { "displayFormat": { "alias": "displayFormat"; "required": false; }; "imageLoadingAttribute": { "alias": "imageLoadingAttribute"; "required": false; }; "user": { "alias": "user"; "required": false; }; "AI": { "alias": "AI"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**