@lucca-front/ng 20.3.3-rc.6 → 21.0.0-rc.1

package/index-table/index.d.ts

@@ -0,0 +1,103 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as _lucca_front_ng_index_table from '@lucca-front/ng/index-table';
+import { PortalContent } from '@lucca-front/ng/core';
+
+declare class IndexTableActionFileComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableActionFileComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableActionFileComponent, "input[luIndexTableAction]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class IndexTableActionComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableActionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableActionComponent, "button[luIndexTableAction], a[luIndexTableAction], label[luIndexTableAction]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class IndexTableBodyComponent {
+    group: _angular_core.InputSignal<PortalContent>;
+    groupButtonAlt: _angular_core.InputSignal<string>;
+    expanded: _angular_core.ModelSignal<boolean>;
+    expandedToggle(): void;
+    protected tableRef: _lucca_front_ng_index_table.IndexTableComponent;
+    colspan: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableBodyComponent, "tbody[luIndexTableBody]", never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; "groupButtonAlt": { "alias": "groupButtonAlt"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
+}
+
+declare abstract class BaseIndexTableCell {
+    tableRef: _lucca_front_ng_index_table.IndexTableComponent;
+    bodyRef: _lucca_front_ng_index_table.IndexTableBodyComponent;
+    headRef: _lucca_front_ng_index_table.IndexTableHeadComponent;
+    footRef: _lucca_front_ng_index_table.IndexTableFootComponent;
+    rowRef: _lucca_front_ng_index_table.IndexTableRowComponent;
+    align: _angular_core.InputSignal<"start" | "center" | "end">;
+    alignCol: _angular_core.Signal<"start" | "center" | "end">;
+    position: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseIndexTableCell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseIndexTableCell, "lu-base-index-table-cell", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IndexTableRowCellHeaderComponent extends BaseIndexTableCell {
+    elementRef: ElementRef<HTMLTableCellElement>;
+    sort: _angular_core.ModelSignal<"ascending" | "descending">;
+    selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hiddenLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    actions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    inlineSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableRowCellHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableRowCellHeaderComponent, "th[luIndexTableCell]", never, { "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "hiddenLabel": { "alias": "hiddenLabel"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "inlineSize": { "alias": "inlineSize"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; }, never, ["*"], true, never>;
+}
+
+declare class IndexTableRowCellComponent extends BaseIndexTableCell {
+    allowTextSelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    tfoot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    actions: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableRowCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableRowCellComponent, "td[luIndexTableCell]", never, { "allowTextSelection": { "alias": "allowTextSelection"; "required": false; "isSignal": true; }; "tfoot": { "alias": "tfoot"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class IndexTableFootComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableFootComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableFootComponent, "tfoot[luIndexTableFoot]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class IndexTableHeadComponent {
+    cols: _angular_core.Signal<readonly IndexTableRowCellHeaderComponent[]>;
+    tableRef: _lucca_front_ng_index_table.IndexTableComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableHeadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableHeadComponent, "thead[luIndexTableHead]", never, {}, {}, ["cols"], ["*"], true, never>;
+}
+
+declare class IndexTableRowComponent {
+    bodyRef: _lucca_front_ng_index_table.IndexTableBodyComponent;
+    headRef: _lucca_front_ng_index_table.IndexTableHeadComponent;
+    footRef: _lucca_front_ng_index_table.IndexTableFootComponent;
+    readonly cells: _angular_core.Signal<readonly BaseIndexTableCell[]>;
+    protected tableRef: _lucca_front_ng_index_table.IndexTableComponent;
+    selected: _angular_core.ModelSignal<boolean>;
+    selectedLabel: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    stack: _angular_core.InputSignalWithTransform<number, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableRowComponent, "tr[luIndexTableRow]", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "stack": { "alias": "stack"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["cells"], ["*"], true, never>;
+}
+
+declare class IndexTableComponent {
+    tableRef: _angular_core.Signal<ElementRef<Element>>;
+    selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    layoutFixed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    empty: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    responsive: _angular_core.InputSignal<Partial<Record<"layoutFixedAtMediaMinXXXS" | "layoutFixedAtMediaMinXXS" | "layoutFixedAtMediaMinXS" | "layoutFixedAtMediaMinS" | "layoutFixedAtMediaMinM" | "layoutFixedAtMediaMinL" | "layoutFixedAtMediaMinXL" | "layoutFixedAtMediaMinXXL" | "layoutFixedAtMediaMinXXXL" | "layoutFixedAtContainerMinXXXS" | "layoutFixedAtContainerMinXXS" | "layoutFixedAtContainerMinXS" | "layoutFixedAtContainerMinS" | "layoutFixedAtContainerMinM" | "layoutFixedAtContainerMinL" | "layoutFixedAtContainerMinXL" | "layoutFixedAtContainerMinXXL" | "layoutFixedAtContainerMinXXXL", true>>>;
+    rows: _angular_core.Signal<readonly IndexTableRowComponent[]>;
+    header: _angular_core.Signal<IndexTableHeadComponent>;
+    cols: _angular_core.Signal<readonly _lucca_front_ng_index_table.IndexTableRowCellHeaderComponent[]>;
+    classMods: _angular_core.Signal<{
+        indexTable: boolean;
+        "mod-selectable": boolean;
+        "mod-layoutFixed": boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IndexTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IndexTableComponent, "lu-index-table", never, { "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "layoutFixed": { "alias": "layoutFixed"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, {}, ["rows", "header"], ["*", "[indexTablePagination]"], true, never>;
+}
+
+export { IndexTableActionComponent, IndexTableActionFileComponent, IndexTableBodyComponent, IndexTableComponent, IndexTableFootComponent, IndexTableHeadComponent, IndexTableRowCellComponent, IndexTableRowCellHeaderComponent, IndexTableRowComponent };

package/input/index.d.ts

@@ -1,7 +1,7 @@
 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';
+import { EventEmitter, ViewRef, TemplateRef, OnInit, ElementRef, Renderer2, ChangeDetectorRef } from '@angular/core';
+import { NgControl, ControlValueAccessor } from '@angular/forms';
 
 interface ILuClearer<T> {
     onClear: Observable<T>;
@@ -14,6 +14,9 @@ interface LuClearerLabel {
     clear: string;
 }
 
+/**
+ * @deprecated use `ClearComponent` instead
+ */
 declare class LuInputClearerComponent<T> extends ALuClearer<T> implements ILuClearer<T> {
     intl: LuClearerLabel;
     onClear: EventEmitter<T>;
@@ -22,6 +25,9 @@ declare class LuInputClearerComponent<T> extends ALuClearer<T> implements ILuCle
     static ɵcmp: i0.ɵɵComponentDeclaration<LuInputClearerComponent<any>, "lu-input-clearer", ["luClearer"], {}, { "onClear": "onClear"; }, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `ClearComponent` instead
+ */
 declare class LuInputClearerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuInputClearerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuInputClearerModule, never, [typeof LuInputClearerComponent], [typeof LuInputClearerComponent]>;
@@ -54,12 +60,30 @@ declare class LuInputDisplayerContext<T> {
     constructor($implicit: T | T[]);
 }
 
+/**
+ * @deprecated use `LuInputDisplayerDirective` instead
+ */
 declare class LuInputDisplayerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuInputDisplayerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuInputDisplayerModule, never, [typeof LuInputDisplayerDirective], [typeof LuInputDisplayerDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuInputDisplayerModule>;
 }
 
+/**
+ * adds class is-filled when model is empty
+ */
+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>;
+}
+
 type ILuInput = ControlValueAccessor;
 declare abstract class ALuInput<T, U extends HTMLElement = HTMLElement> implements ILuInput {
     protected _changeDetectorRef: ChangeDetectorRef;
@@ -83,20 +107,8 @@ declare abstract class ALuInput<T, U extends HTMLElement = HTMLElement> implemen
 }
 
 /**
- * adds class is-filled when model is empty
+ * @deprecated use `LuInputDirective, LuInputDisplayerDirective, LuInputClearerComponent` instead
  */
-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]>;

package/link/index.d.ts

@@ -20,9 +20,9 @@ declare class LinkComponent {
     intl: LinkTranslate;
     routerLink: LuRouterLink;
     router: Router;
-    luHref: i0.InputSignal<string>;
-    routerLinkCommands: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree>;
-    disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly luHref: i0.InputSignal<string>;
+    readonly routerLinkCommands: i0.InputSignal<string | readonly any[] | _angular_router.UrlTree>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
     decorationHover: boolean;
     external: boolean;
     get relAttr(): string;
@@ -30,7 +30,6 @@ declare class LinkComponent {
     get roleAttr(): string;
     get disabledClass(): boolean;
     redirect(): void;
-    hrefBackup: string;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<LinkComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<LinkComponent, "a[luLink], button[luLink]", never, { "luHref": { "alias": "href"; "required": false; "isSignal": true; }; "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 LuRouterLink; inputs: { "preserveFragment": "preserveFragment"; "skipLocationChange": "skipLocationChange"; "replaceUrl": "replaceUrl"; "queryParams": "queryParams"; "fragment": "fragment"; "queryParamsHandling": "queryParamsHandling"; "state": "state"; "info": "info"; "relativeTo": "relativeTo"; }; outputs: {}; }]>;

package/listbox/index.d.ts

@@ -1,11 +1,11 @@
 import * as _angular_core from '@angular/core';
 
 declare class ListboxComponent {
-    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    tree: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    state: _angular_core.InputSignal<"loading" | "empty">;
-    statusMsg: _angular_core.InputSignal<string>;
-    listboxId: string;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tree: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly state: _angular_core.InputSignal<"loading" | "empty">;
+    readonly statusMsg: _angular_core.InputSignal<string>;
+    readonly listboxId: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListboxComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListboxComponent, "lu-listbox", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "tree": { "alias": "tree"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "statusMsg": { "alias": "statusMsg"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -16,21 +16,21 @@ declare class Treeitem {
 }
 declare class OptionComponent {
     #private;
-    multiple: _angular_core.Signal<boolean>;
-    tree: _angular_core.Signal<boolean>;
-    empty: _angular_core.Signal<boolean>;
-    id: _angular_core.Signal<string>;
-    checked: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    mixed: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    hovered: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    add: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    group: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    select: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    selectAll: _angular_core.InputSignal<"string">;
-    groupId: string;
-    treeitemContent: _angular_core.Signal<Treeitem>;
-    level: number;
+    readonly multiple: _angular_core.Signal<boolean>;
+    readonly tree: _angular_core.Signal<boolean>;
+    readonly empty: _angular_core.Signal<boolean>;
+    readonly id: _angular_core.Signal<string>;
+    readonly checked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly mixed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hovered: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly add: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly group: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly select: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectAll: _angular_core.InputSignal<"string">;
+    readonly groupId: string;
+    readonly treeitemContent: _angular_core.Signal<Treeitem>;
+    readonly level: number;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OptionComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OptionComponent, "lu-listbox-option", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "mixed": { "alias": "mixed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hovered": { "alias": "hovered"; "required": false; "isSignal": true; }; "add": { "alias": "add"; "required": false; "isSignal": true; }; "group": { "alias": "group"; "required": false; "isSignal": true; }; "select": { "alias": "select"; "required": false; "isSignal": true; }; "selectAll": { "alias": "selectAll"; "required": false; "isSignal": true; }; }, {}, ["treeitemContent"], ["*", "[optgroup]", "[treeitem]"], true, never>;
 }

package/listing/index.d.ts

@@ -4,23 +4,27 @@ import { LuccaIcon } from '@lucca-front/icons';
 import { Palette } from '@lucca-front/ng/core';
 
 declare class ListingItemComponent {
-    icon: _angular_core.InputSignal<LuccaIcon>;
+    readonly icon: _angular_core.InputSignal<LuccaIcon>;
     protected listingRef: _lucca_front_ng_listing.ListingComponent;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingItemComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListingItemComponent, "lu-listing-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class ListingComponent {
-    ordered: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    checklist: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    icons: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    defaultIcon: _angular_core.InputSignal<LuccaIcon>;
-    palette: _angular_core.InputSignal<Palette>;
-    get paletteClass(): {
+    readonly ordered: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly checklist: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly icons: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly defaultIcon: _angular_core.InputSignal<LuccaIcon>;
+    readonly palette: _angular_core.InputSignal<Palette>;
+    readonly start: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly inline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly divider: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly reversed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly paletteClass: _angular_core.Signal<{
         [x: string]: boolean;
-    };
+    }>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListingComponent, "lu-listing", never, { "ordered": { "alias": "ordered"; "required": false; "isSignal": true; }; "checklist": { "alias": "checklist"; "required": false; "isSignal": true; }; "icons": { "alias": "icons"; "required": false; "isSignal": true; }; "defaultIcon": { "alias": "defaultIcon"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListingComponent, "lu-listing", never, { "ordered": { "alias": "ordered"; "required": false; "isSignal": true; }; "checklist": { "alias": "checklist"; "required": false; "isSignal": true; }; "icons": { "alias": "icons"; "required": false; "isSignal": true; }; "defaultIcon": { "alias": "defaultIcon"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; "start": { "alias": "start"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "reversed": { "alias": "reversed"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 export { ListingComponent, ListingItemComponent };

package/loading/index.d.ts

@@ -2,10 +2,10 @@ import * as _angular_core from '@angular/core';
 
 declare class LoadingComponent {
     #private;
-    size: _angular_core.InputSignal<"L">;
-    invert: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    block: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    template: _angular_core.InputSignal<"popin" | "drawer" | "fullpage">;
+    readonly size: _angular_core.InputSignal<"L">;
+    readonly invert: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly block: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly template: _angular_core.InputSignal<"popin" | "drawer" | "fullpage">;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoadingComponent, "lu-loading", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invert": { "alias": "invert"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

package/main-layout/index.d.ts

@@ -1,14 +1,14 @@
 import * as i0 from '@angular/core';
 
 declare class MainLayoutBlockComponent {
-    overflow: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly overflow: i0.InputSignalWithTransform<boolean, unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainLayoutBlockComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MainLayoutBlockComponent, "lu-main-layout-block", never, { "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class MainLayoutComponent {
-    headerSticky: i0.InputSignalWithTransform<boolean, unknown>;
-    footerSticky: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly headerSticky: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly footerSticky: i0.InputSignalWithTransform<boolean, unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MainLayoutComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MainLayoutComponent, "lu-main-layout", never, { "headerSticky": { "alias": "headerSticky"; "required": false; "isSignal": true; }; "footerSticky": { "alias": "footerSticky"; "required": false; "isSignal": true; }; }, {}, never, ["[mainLayoutSidebar]", "[mainLayoutHeader]", "*", "[mainLayoutFooter]"], true, never>;
 }

package/modal/index.d.ts

@@ -95,13 +95,11 @@ declare abstract class ALuModalPanelComponent<T extends ILuModalContent> impleme
     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>;
@@ -134,6 +132,9 @@ declare class LuModalRefFactory implements ILuPopupRefFactory<ILuModalContent, L
  * Note that OverlayModule should be imported in one of the EnvironmentInjectors (AppModule, lazy-loaded route) using `providers: [importProvidersFrom(OverlayModule)]`.
  */
 declare function provideLuModal(): Provider[];
+/**
+ * @deprecated use `OverlayModule, DialogModule` imports && provide `provideLuModal(), LuDialogService` instead
+ */
 declare class LuModalModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuModalModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuModalModule, never, [typeof i1.OverlayModule, typeof i2.DialogModule], never>;

package/multi-select/index.d.ts

@@ -1,10 +1,10 @@
 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 { ɵIsSelectedStrategy as _IsSelectedStrategy, LuSelectPanelRef, ALuSelectInputComponent, LuOptionContext, ILuOptionContext } from '@lucca-front/ng/core-select';
+import * as rxjs from 'rxjs';
+import { Subject, BehaviorSubject } from 'rxjs';
 import { Overlay, OverlayPositionBuilder, ScrollStrategyOptions, OverlayConfig, ConnectedPosition } from '@angular/cdk/overlay';
 import * as i1 from '@lucca-front/ng/form-field';
 import { LuOptionComparer } from '@lucca-front/ng/option';
@@ -56,6 +56,7 @@ interface ILuMultiSelectLabel {
     clear: string;
     clearSearch: string;
     emptyResults: string;
+    emptyOptions: string;
     emptySelection: string;
     expand: string;
     reduce: string;
@@ -138,8 +139,15 @@ declare class LuMultiSelectInputComponent<T> extends ALuSelectInputComponent<T,
     static ngAcceptInputType_keepSearchAfterSelection: unknown;
 }
 
+declare class LuMultiSelectContentDisplayerComponent<T> {
+    select: LuMultiSelectInputComponent<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuMultiSelectContentDisplayerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuMultiSelectContentDisplayerComponent<any>, "lu-multi-select-content-displayer", never, {}, {}, never, ["*"], true, never>;
+}
+
 declare class LuMultiSelectCounterDisplayerComponent<T> implements OnInit {
     select: LuMultiSelectInputComponent<T>;
+    context: ILuOptionContext<T[]>;
     protected destroyRef: DestroyRef;
     inputElementRef: ElementRef<HTMLInputElement>;
     get value(): T[];
@@ -179,8 +187,10 @@ declare class LuMultiSelectDefaultDisplayerComponent<T> implements OnInit {
 
 declare class LuMultiSelectDisplayerInputDirective<T> implements OnInit {
     #private;
+    intl: ILuMultiSelectLabel;
     select: LuMultiSelectInputComponent<T>;
     readonly selectAllContext: LuMultiSelectWithSelectAllContext;
+    contentDisplayer: LuMultiSelectContentDisplayerComponent<any>;
     context: ILuOptionContext<T[]>;
     elementRef: ElementRef<HTMLInputElement>;
     destroyRef: DestroyRef;
@@ -224,5 +234,5 @@ 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 { LU_MULTI_SELECT_DISPLAYER_TRANSLATIONS, LU_MULTI_SELECT_TRANSLATIONS, LuMultiDisplayerDirective, LuMultiSelectContentDisplayerComponent, LuMultiSelectCounterDisplayerComponent, LuMultiSelectDefaultDisplayerComponent, LuMultiSelectDisplayerInputDirective, LuMultiSelectInputComponent, LuMultiSelectWithSelectAllDirective, LuMultiSelectionValidators, luMultiSelectDisplayerTranslations, luMultiSelectTranslations, selectionToOptions, selectionToQueryParams };
 export type { ILuMultiSelectDisplayerLabel, ILuMultiSelectLabel, LuMultiSelection, LuMultiSelectionMode };

package/number/index.d.ts

@@ -9,6 +9,9 @@ declare class LuNumberPipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<LuNumberPipe, "luNumber", true>;
 }
 
+/**
+ * @deprecated use `LuNumberPipe` instead
+ */
 declare class LuNumberModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuNumberModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuNumberModule, never, [typeof LuNumberPipe], [typeof LuNumberPipe]>;

package/option/index.d.ts

@@ -51,6 +51,9 @@ declare class LuOptionItemComponent<T> extends ALuOptionItem<T> implements ILuOp
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionItemComponent<any>, "lu-option", never, { "selected": { "alias": "selected"; "required": false; }; "highlighted": { "alias": "highlighted"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelect": "onSelect"; }, never, ["*"], true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionItemComponent` instead
+ */
 declare class LuOptionItemModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionItemModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionItemModule, never, [typeof LuOptionItemComponent], [typeof LuOptionItemComponent]>;
@@ -116,7 +119,7 @@ declare class LuTreeOptionItemComponent<T> extends ALuTreeOptionItem<T> implemen
 }
 
 /**
- * @deprecated
+ * @deprecated use `LuTreeOptionItemComponent` instead
  */
 declare class LuTreeOptionItemModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionItemModule, never>;
@@ -230,6 +233,9 @@ declare class LuOptionFeederComponent<T> implements ILuOptionOperator<T> {
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionFeederComponent<any>, "lu-option-feeder", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionFeederComponent` instead
+ */
 declare class LuOptionFeederModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionFeederModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionFeederModule, never, [typeof LuOptionFeederComponent], [typeof LuOptionFeederComponent]>;
@@ -250,6 +256,9 @@ declare class LuTreeOptionFeederComponent<T> implements ILuTreeOptionOperator<T>
     static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionFeederComponent<any>, "lu-tree-option-feeder", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuTreeOptionFeederComponent` instead
+ */
 declare class LuTreeOptionFeederModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionFeederModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionFeederModule, never, [typeof LuTreeOptionFeederComponent], [typeof LuTreeOptionFeederComponent]>;
@@ -266,6 +275,9 @@ declare class LuOptionPagerComponent<T> extends ALuOptionOperator<T> implements
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPagerComponent<any>, "lu-option-pager", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionPagerComponent` instead
+ */
 declare class LuOptionPagerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPagerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionPagerModule, never, [typeof LuOptionPagerComponent], [typeof LuOptionPagerComponent]>;
@@ -288,6 +300,9 @@ declare class LuTreeOptionPagerComponent<T> extends ALuTreeOptionOperator<T> imp
     static ɵcmp: i0.ɵɵComponentDeclaration<LuTreeOptionPagerComponent<any>, "lu-tree-option-pager", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuTreeOptionPagerComponent` instead
+ */
 declare class LuTreeOptionPagerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionPagerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionPagerModule, never, [typeof LuTreeOptionPagerComponent], [typeof LuTreeOptionPagerComponent]>;
@@ -308,6 +323,9 @@ declare class LuOptionSearcherComponent<T> extends ALuOptionOperator<T> implemen
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionSearcherComponent<any>, "lu-option-searcher", never, { "searchFn": { "alias": "searchFn"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionSearcherComponent` instead
+ */
 declare class LuOptionSearcherModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSearcherModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionSearcherModule, never, [typeof LuOptionSearcherComponent], [typeof LuOptionSearcherComponent]>;
@@ -333,7 +351,7 @@ declare class LuTreeOptionSearcherComponent<T> extends ALuTreeOptionOperator<T>
 }
 
 /**
- * @deprecated
+ * @deprecated use `LuTreeOptionSearcherComponent` instead
  */
 declare class LuTreeOptionSearcherModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionSearcherModule, never>;
@@ -368,6 +386,9 @@ declare class LuForGroupsDirective<TItem, TKey> implements ILuOptionOperator<TIt
     static ɵdir: i0.ɵɵDirectiveDeclaration<LuForGroupsDirective<any, any>, "[luForGroups]", never, { "attrGroupBy": { "alias": "luForGroupsGroupBy"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuForGroupsDirective` instead
+ */
 declare class LuForGroupsModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuForGroupsModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuForGroupsModule, never, [typeof LuForGroupsDirective], [typeof LuForGroupsDirective]>;
@@ -386,6 +407,9 @@ declare class LuForOptionsDirective<T> extends NgForOf<T> implements ILuOptionOp
     static ɵdir: i0.ɵɵDirectiveDeclaration<LuForOptionsDirective<any>, "[luForOptions]", never, { "luForOptionsTrackBy": { "alias": "luForOptionsTrackBy"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuForOptionsDirective` instead
+ */
 declare class LuForOptionsModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuForOptionsModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuForOptionsModule, never, [typeof LuForOptionsDirective], [typeof LuForOptionsDirective]>;
@@ -400,12 +424,18 @@ declare class LuForTreeOptionsDirective<T> extends LuForOptionsDirective<ILuTree
     static ɵdir: i0.ɵɵDirectiveDeclaration<LuForTreeOptionsDirective<any>, "[luForTreeOptions]", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuForTreeOptionsDirective` instead
+ */
 declare class LuForTreeOptionsModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuForTreeOptionsModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuForTreeOptionsModule, never, [typeof LuForTreeOptionsDirective], [typeof LuForTreeOptionsDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuForTreeOptionsModule>;
 }
 
+/**
+ * @deprecated use `LuOptionPagerComponent, LuOptionFeederComponent, LuOptionSearcherComponent, LuForOptionsDirective, LuForGroupsDirective` instead
+ */
 declare class LuOptionOperatorModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionOperatorModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionOperatorModule, never, [typeof LuOptionPagerComponent, typeof LuOptionFeederComponent, typeof LuOptionSearcherComponent, typeof LuForOptionsDirective, typeof LuForGroupsDirective], [typeof LuOptionPagerComponent, typeof LuOptionFeederComponent, typeof LuOptionSearcherComponent, typeof LuForOptionsDirective, typeof LuForGroupsDirective]>;
@@ -413,7 +443,7 @@ declare class LuOptionOperatorModule {
 }
 
 /**
- * @deprecated
+ * @deprecated use `LuTreeOptionFeederComponent, LuForTreeOptionsDirective, LuTreeOptionPagerComponent, LuTreeOptionSearcherComponent` instead
  */
 declare class LuTreeOptionOperatorModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionOperatorModule, never>;
@@ -458,12 +488,18 @@ declare class LuOptionSelectAllComponent<T> extends ALuOptionOperator<T> impleme
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionSelectAllComponent<any>, "lu-option-select-all", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionSelectAllComponent` instead
+ */
 declare class LuOptionSelectAllModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSelectAllModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionSelectAllModule, never, [typeof LuOptionSelectAllComponent], [typeof LuOptionSelectAllComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionSelectAllModule>;
 }
 
+/**
+ * @deprecated use `LuOptionSelectAllComponent` instead
+ */
 declare class LuOptionSelectorModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionSelectorModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionSelectorModule, never, [typeof LuOptionSelectAllModule], [typeof LuOptionSelectAllModule]>;
@@ -495,7 +531,7 @@ declare class LuTreeOptionSelectAllComponent<T> extends ALuTreeOptionOperator<T>
 }
 
 /**
- * @deprecated
+ * @deprecated use `LuTreeOptionSelectAllComponent` instead
  */
 declare class LuTreeOptionSelectAllModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionSelectAllModule, never>;
@@ -503,6 +539,9 @@ declare class LuTreeOptionSelectAllModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<LuTreeOptionSelectAllModule>;
 }
 
+/**
+ * @deprecated use `LuTreeOptionSelectAllComponent` instead
+ */
 declare class LuTreeOptionSelectorModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuTreeOptionSelectorModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuTreeOptionSelectorModule, never, [typeof LuTreeOptionSelectAllModule], [typeof LuTreeOptionSelectAllModule]>;
@@ -547,6 +586,9 @@ declare class LuOptionPickerAdvancedComponent<T, O extends ILuOptionItem<T> = IL
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPickerAdvancedComponent<any, any>, "lu-option-picker-advanced", ["LuOptionPickerAdvanced"], {}, {}, never, ["*"], true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent` instead
+ */
 declare class LuOptionPickerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPickerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionPickerModule, never, [typeof LuOptionPickerComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionItemComponent], [typeof LuOptionPickerComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionItemComponent]>;
@@ -656,12 +698,24 @@ declare class LuOptionPlaceholderComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<LuOptionPlaceholderComponent, "lu-option-placeholder", never, {}, { "onClear": "onClear"; }, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuOptionPlaceholderComponent` instead
+ */
 declare class LuOptionPlaceholderModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionPlaceholderModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionPlaceholderModule, never, [typeof LuOptionPlaceholderComponent], [typeof LuOptionPlaceholderComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuOptionPlaceholderModule>;
 }
 
+/**
+ * @deprecated use `LuOptionItemComponent, LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionPagerComponent,
+        LuOptionFeederComponent,
+        LuOptionSearcherComponent,
+        LuForOptionsDirective,
+        LuForGroupsDirective,
+        LuOptionSelectAllComponent,
+        LuOptionPlaceholderComponent` instead
+ */
 declare class LuOptionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuOptionModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuOptionModule, never, [typeof LuOptionItemComponent, typeof LuOptionPickerComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionPagerComponent, typeof LuOptionFeederComponent, typeof LuOptionSearcherComponent, typeof LuForOptionsDirective, typeof LuForGroupsDirective, typeof LuOptionSelectAllComponent, typeof LuOptionPlaceholderComponent], [typeof LuOptionItemComponent, typeof LuOptionPickerAdvancedComponent, typeof LuOptionPickerComponent, typeof LuOptionPagerComponent, typeof LuOptionFeederComponent, typeof LuOptionSearcherComponent, typeof LuForOptionsDirective, typeof LuForGroupsDirective, typeof LuOptionSelectAllComponent, typeof LuOptionPlaceholderComponent]>;