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

package/api/index.d.ts

@@ -122,6 +122,9 @@ declare class LuApiFeederComponent<T extends ILuApiItem = ILuApiItem> extends AL
     static ɵcmp: i0.ɵɵComponentDeclaration<LuApiFeederComponent<any>, "lu-api-feeder", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuApiFeederComponent` instead
+ */
 declare class LuApiFeederModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuApiFeederModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiFeederModule, never, [typeof LuApiFeederComponent], [typeof LuApiFeederComponent]>;
@@ -261,30 +264,45 @@ declare class LuApiSelectInputComponent<T extends ILuApiItem = ILuApiItem> exten
     static ɵcmp: i0.ɵɵComponentDeclaration<LuApiSelectInputComponent<any>, "lu-api-select", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuApiFeederComponent, LuApiPagedSearcherComponent, LuApiSearcherComponent, LuApiPagerComponent, LuApiSelectInputComponent` instead
+ */
 declare class LuApiSelectModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSelectModule, never, [typeof LuApiFeederComponent, typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent, typeof LuApiPagerComponent, typeof LuApiSelectInputComponent], [typeof LuApiFeederComponent, typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent, typeof LuApiPagerComponent, typeof LuApiSelectInputComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSelectModule>;
 }
 
+/**
+ * @deprecated use `LuApiFeederComponent, LuApiPagedSearcherComponent, LuApiSearcherComponent, LuApiPagerComponent, LuApiSelectInputComponent` instead
+ */
 declare class LuApiModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuApiModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiModule, never, [typeof LuApiSelectModule], [typeof LuApiSelectModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuApiModule>;
 }
 
+/**
+ * @deprecated use `LuApiPagedSearcherComponent, LuApiSearcherComponent` instead
+ */
 declare class LuApiSearcherModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSearcherModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSearcherModule, never, [typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent], [typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSearcherModule>;
 }
 
+/**
+ * @deprecated use `LuApiPagerComponent` instead
+ */
 declare class LuApiPagerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuApiPagerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiPagerModule, never, [typeof LuApiPagerComponent], [typeof LuApiPagerComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuApiPagerModule>;
 }
 
+/**
+ * @deprecated use `LuApiSelectInputComponent` instead
+ */
 declare class LuApiSelectInputModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectInputModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSelectInputModule, never, [typeof LuApiSelectInputComponent], [typeof LuApiSelectInputComponent]>;

package/breadcrumbs/index.d.ts

@@ -16,9 +16,7 @@ declare class BreadcrumbsComponent {
     disableCompact: i0.InputSignalWithTransform<boolean, unknown>;
     links: i0.Signal<readonly BreadcrumbsLinkDirective[]>;
     isCompact: i0.Signal<boolean>;
-    id: string;
-    get classCompact(): boolean;
-    get roleAttr(): string;
+    readonly id: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbsComponent, "lu-breadcrumbs", never, { "disableCompact": { "alias": "disableCompact"; "required": false; "isSignal": true; }; }, {}, ["links"], never, true, never>;
 }

package/callout/index.d.ts

@@ -73,9 +73,14 @@ declare class CalloutPopoverComponent implements OnDestroy {
      */
     readonly closeDelay = 500;
     /**
-     * Label to put inside the button, often used to show just a number
+     * Label (visual only) to put inside the button, often used to show just a number
      */
     buttonLabel: string;
+    /**
+     * Alternative for the button
+     */
+    buttonAlt: i0.InputSignal<string>;
+    headingHiddenIfSingleItem: i0.InputSignalWithTransform<boolean, unknown>;
     /**
      * Palette for both the button and the popover content
      */
@@ -100,6 +105,7 @@ declare class CalloutPopoverComponent implements OnDestroy {
      * Heading for the details popover
      */
     heading: PortalContent;
+    feedbackItems: i0.Signal<readonly CalloutFeedbackItemComponent[]>;
     get contentSize(): 'S' | 'M' | undefined;
     get calloutClasses(): {
         [x: string]: boolean;
@@ -115,7 +121,7 @@ declare class CalloutPopoverComponent implements OnDestroy {
     hideContent(event: MouseEvent | null): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CalloutPopoverComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutPopoverComponent, "lu-callout-popover", never, { "openDelay": { "alias": "openDelay"; "required": false; }; "closeDelay": { "alias": "closeDelay"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "state": { "alias": "state"; "required": false; }; "heading": { "alias": "heading"; "required": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutPopoverComponent, "lu-callout-popover", never, { "openDelay": { "alias": "openDelay"; "required": false; }; "closeDelay": { "alias": "closeDelay"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "buttonAlt": { "alias": "buttonAlt"; "required": false; "isSignal": true; }; "headingHiddenIfSingleItem": { "alias": "headingHiddenIfSingleItem"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "state": { "alias": "state"; "required": false; }; "heading": { "alias": "heading"; "required": false; }; }, {}, ["feedbackItems"], ["*"], true, never>;
     static ngAcceptInputType_openDelay: unknown;
     static ngAcceptInputType_closeDelay: unknown;
 }

package/chip/index.d.ts

@@ -6,13 +6,14 @@ interface ChipTranslate {
 
 declare class ChipComponent {
     intl: ChipTranslate;
+    withEllipsis: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly unkillable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly palette: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly classPalette: _angular_core.Signal<boolean>;
-    readonly kill: _angular_core.OutputEmitterRef<void>;
+    readonly kill: _angular_core.OutputEmitterRef<Event>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "lu-chip", never, { "unkillable": { "alias": "unkillable"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "kill": "kill"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "lu-chip", never, { "withEllipsis": { "alias": "withEllipsis"; "required": false; "isSignal": true; }; "unkillable": { "alias": "unkillable"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "kill": "kill"; }, never, ["*"], true, never>;
 }
 
 export { ChipComponent };

package/clear/index.d.ts

@@ -0,0 +1,30 @@
+import * as _angular_core from '@angular/core';
+import { EventEmitter, ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+
+interface LuClearLabel {
+    clear: string;
+}
+
+interface ILuClear<T> {
+    onClear: Observable<T>;
+}
+declare abstract class ALuClear<T> implements ILuClear<T> {
+    onClear: Observable<T>;
+}
+
+declare class ClearComponent<T> extends ALuClear<T> implements ILuClear<T> {
+    intl: LuClearLabel;
+    size: _angular_core.InputSignal<"S">;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    product: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    inverted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    onClear: EventEmitter<T>;
+    contentRef: _angular_core.Signal<readonly ElementRef<any>[]>;
+    clear($event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClearComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClearComponent<any>, "lu-clear", ["luClearer"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "product": { "alias": "product"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; }, { "onClear": "onClear"; }, ["contentRef"], ["*"], true, never>;
+}
+
+export { ALuClear, ClearComponent };
+export type { ILuClear };

package/code/index.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from '@angular/core';
+
+declare class codeComponent {
+    block: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<codeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<codeComponent, "lu-code", never, { "block": { "alias": "block"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { codeComponent };

package/container/index.d.ts

@@ -4,11 +4,11 @@ declare class ContainerComponent {
     center: _angular_core.InputSignalWithTransform<boolean, unknown>;
     overflow: _angular_core.InputSignalWithTransform<boolean, unknown>;
     max: _angular_core.InputSignal<"M" | "L" | "XL" | "XXL" | "XXXL">;
-    get classesConfig(): {
+    classesConfig: _angular_core.Signal<{
         [x: string]: boolean;
         "mod-center": boolean;
         "mod-overflow": boolean;
-    };
+    }>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContainerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContainerComponent, "lu-container", never, { "center": { "alias": "center"; "required": false; "isSignal": true; }; "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/core/index.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, TemplateRef, Type, OnChanges, OnDestroy, SimpleChanges, Signal, CreateEffectOptions, PipeTransform } from '@angular/core';
+import { InjectionToken, TemplateRef, Type, OnDestroy, Signal, CreateEffectOptions, PipeTransform } from '@angular/core';
 
 /**
  * Extracts the values of an enum as a union type.
@@ -159,18 +159,18 @@ declare const isNotNil: <T>(value: T) => value is NonNullable<T>;
 type PortalContent<T = unknown> = string | TemplateRef<T> | Type<unknown>;
 declare const PORTAL_CONTEXT: InjectionToken<unknown>;
 
-declare class PortalDirective<T = unknown> implements OnChanges, OnDestroy {
+declare class PortalDirective<T = unknown> implements OnDestroy {
     private viewContainerRef;
     private renderer;
     private templateRef;
     private injector;
-    luPortal: PortalContent<T>;
-    luPortalContext: T | null;
+    luPortal: i0.InputSignal<PortalContent<T>>;
+    luPortalContext: i0.InputSignal<T>;
     private createdTextElement;
     private embeddedViewRef?;
     private componentRef?;
+    constructor();
     private render;
-    ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
     private renderText;
     private destroyRenderedText;
@@ -181,7 +181,7 @@ declare class PortalDirective<T = unknown> implements OnChanges, OnDestroy {
     private updateEmbeddedViewContext;
     static ngTemplateContextGuard<T>(_dir: PortalDirective<T>, ctx: unknown): ctx is void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PortalDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalDirective<any>, "[luPortal]", never, { "luPortal": { "alias": "luPortal"; "required": true; }; "luPortalContext": { "alias": "luPortalContext"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalDirective<any>, "[luPortal]", never, { "luPortal": { "alias": "luPortal"; "required": true; "isSignal": true; }; "luPortalContext": { "alias": "luPortalContext"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type EffectWithDepsValues<T> = T extends readonly unknown[] ? TupleOfSignalValues<T> : [RecordOfSignalValues<T>];

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

@@ -3,8 +3,8 @@ import { OnInit } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { TreeNode, TreeGenerator, TreeGroupingFn, CoreSelectApiTotalCountProvider } from '@lucca-front/ng/core-select';
 import { ALuCoreSelectApiDirective } from '@lucca-front/ng/core-select/api';
-import { Observable } from 'rxjs';
 import { ILuDepartment } from '@lucca-front/ng/department';
+import { Observable } from 'rxjs';
 import { ILuApiItem } from '@lucca-front/ng/api';
 
 declare class NoopTreeSelectDirective<T extends TreeNode<any>, V> implements TreeGenerator<T, T> {

package/core-select/index.d.ts

@@ -257,6 +257,7 @@ declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDes
     placeholder$: BehaviorSubject<string>;
     disabled$: BehaviorSubject<boolean>;
     filterPillDisabled: i0.Signal<boolean>;
+    prefix: i0.InputSignal<PortalContent>;
     set placeholder(value: string);
     set clearable(value: boolean);
     get clearable(): boolean;
@@ -341,7 +342,7 @@ declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDes
     onFilterPillOpened(): void;
     onFilterPillClosed(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ALuSelectInputComponent<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuSelectInputComponent<any, any>, never, never, { "placeholder": { "alias": "placeholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "addOptionLabel": { "alias": "addOptionLabel"; "required": false; }; "addOptionStrategy": { "alias": "addOptionStrategy"; "required": false; }; "overlayConfig": { "alias": "overlayConfig"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionComparer": { "alias": "optionComparer"; "required": false; }; "optionKey": { "alias": "optionKey"; "required": false; }; "noClueIcon": { "alias": "noClueIcon"; "required": false; "isSignal": true; }; "inputTabindex": { "alias": "inputTabindex"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "valueTpl": { "alias": "valueTpl"; "required": false; "isSignal": true; }; "panelHeaderTpl": { "alias": "panelHeaderTpl"; "required": false; "isSignal": true; }; }, { "panelClosed": "panelClosed"; "panelOpened": "panelOpened"; "optionTpl": "optionTplChange"; "valueTpl": "valueTplChange"; "panelHeaderTpl": "panelHeaderTplChange"; "clueChange": "clueChange"; "nextPage": "nextPage"; "previousPage": "previousPage"; "addOption": "addOption"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuSelectInputComponent<any, any>, never, never, { "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "addOptionLabel": { "alias": "addOptionLabel"; "required": false; }; "addOptionStrategy": { "alias": "addOptionStrategy"; "required": false; }; "overlayConfig": { "alias": "overlayConfig"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionComparer": { "alias": "optionComparer"; "required": false; }; "optionKey": { "alias": "optionKey"; "required": false; }; "noClueIcon": { "alias": "noClueIcon"; "required": false; "isSignal": true; }; "inputTabindex": { "alias": "inputTabindex"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "valueTpl": { "alias": "valueTpl"; "required": false; "isSignal": true; }; "panelHeaderTpl": { "alias": "panelHeaderTpl"; "required": false; "isSignal": true; }; }, { "panelClosed": "panelClosed"; "panelOpened": "panelOpened"; "optionTpl": "optionTplChange"; "valueTpl": "valueTplChange"; "panelHeaderTpl": "panelHeaderTplChange"; "clueChange": "clueChange"; "nextPage": "nextPage"; "previousPage": "previousPage"; "addOption": "addOption"; }, never, never, true, never>;
     static ngAcceptInputType_clearable: unknown;
 }
 

package/core-select/occupation-category/index.d.ts

@@ -0,0 +1,26 @@
+import { ILuApiItem } from '@lucca-front/ng/api';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { CoreSelectApiTotalCountProvider } from '@lucca-front/ng/core-select';
+import { ALuCoreSelectApiDirective } from '@lucca-front/ng/core-select/api';
+import { Observable } from 'rxjs';
+
+type LuCoreSelectOccupationCategory = ILuApiItem;
+
+declare class LuCoreSelectOccupationCategoriesDirective<T extends LuCoreSelectOccupationCategory = LuCoreSelectOccupationCategory> extends ALuCoreSelectApiDirective<T> implements OnInit, CoreSelectApiTotalCountProvider {
+    protected httpClient: HttpClient;
+    url: _angular_core.InputSignal<string>;
+    filters: _angular_core.InputSignal<Record<string, string | number | boolean>>;
+    searchDelimiter: _angular_core.InputSignal<string>;
+    protected clue: _angular_core.Signal<string>;
+    protected getOptions(params: Record<string, string | number | boolean> | null, page: number): Observable<T[]>;
+    protected params$: Observable<Record<string, string | number | boolean>>;
+    totalCount$: Observable<number>;
+    protected optionKey: (option: T) => number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectOccupationCategoriesDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectOccupationCategoriesDirective<any>, "lu-simple-select[occupationCategories],lu-multi-select[occupationCategories]", ["occupationCategories"], { "url": { "alias": "url"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "searchDelimiter": { "alias": "searchDelimiter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { LuCoreSelectOccupationCategoriesDirective };
+export type { LuCoreSelectOccupationCategory };

package/data-table/index.d.ts

@@ -1,6 +1,6 @@
 import * as _lucca_front_ng_data_table from '@lucca-front/ng/data-table';
 import * as _angular_core from '@angular/core';
-import { ElementRef } from '@angular/core';
+import { AfterContentInit, ElementRef } from '@angular/core';
 import { PortalContent } from '@lucca-front/ng/core';
 
 declare class DataTableBodyComponent {
@@ -14,27 +14,43 @@ declare class DataTableBodyComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableBodyComponent, "tbody[luDataTableBody]", 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 class DataTableRowCellHeaderComponent {
+declare abstract class BaseDataTableCell {
+    tableRef: _lucca_front_ng_data_table.DataTableComponent;
     bodyRef: _lucca_front_ng_data_table.DataTableBodyComponent;
     headRef: _lucca_front_ng_data_table.DataTableHeadComponent;
     footRef: _lucca_front_ng_data_table.DataTableFootComponent;
-    sort: _angular_core.ModelSignal<"ascending" | "descending">;
-    fixedWidth: _angular_core.InputSignal<string>;
+    rowRef: _lucca_front_ng_data_table.DataTableRowComponent;
     editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     align: _angular_core.InputSignal<"start" | "center" | "end">;
+    isStickyStart: _angular_core.Signal<boolean>;
+    isStickyEnd: _angular_core.Signal<boolean>;
+    position: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseDataTableCell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseDataTableCell, "lu-base-data-table-cell", never, { "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DataTableRowCellHeaderComponent extends BaseDataTableCell implements AfterContentInit {
+    #private;
+    elementRef: ElementRef<HTMLTableCellElement>;
+    sort: _angular_core.ModelSignal<"ascending" | "descending">;
+    fixedWidth: _angular_core.InputSignal<string>;
+    inlineSize: _angular_core.InputSignal<string>;
+    insetInlineStart: _angular_core.Signal<string>;
+    insetInlineEnd: _angular_core.Signal<string>;
+    inlineSizePx: _angular_core.Signal<number>;
+    ngAfterContentInit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableRowCellHeaderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableRowCellHeaderComponent, "th[luDataTableCell]", never, { "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "fixedWidth": { "alias": "fixedWidth"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableRowCellHeaderComponent, "th[luDataTableCell]", never, { "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "fixedWidth": { "alias": "fixedWidth"; "required": false; "isSignal": true; }; "inlineSize": { "alias": "inlineSize"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; }, never, ["*"], true, never>;
 }
 
-declare class DataTableRowCellComponent {
-    bodyRef: _lucca_front_ng_data_table.DataTableBodyComponent;
-    headRef: _lucca_front_ng_data_table.DataTableHeadComponent;
-    footRef: _lucca_front_ng_data_table.DataTableFootComponent;
-    align: _angular_core.InputSignal<"start" | "center" | "end">;
-    editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+declare class DataTableRowCellComponent extends BaseDataTableCell {
     actions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isSticky: _angular_core.Signal<boolean>;
+    alignCol: _angular_core.Signal<"start" | "center" | "end">;
+    insetInlineStart: _angular_core.Signal<string>;
+    insetInlineEnd: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableRowCellComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableRowCellComponent, "td[luDataTableCell]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableRowCellComponent, "td[luDataTableCell]", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class DataTableFootComponent {
@@ -43,41 +59,56 @@ declare class DataTableFootComponent {
 }
 
 declare class DataTableHeadComponent {
-    sticky: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    isFirstVisible: _angular_core.WritableSignal<boolean>;
+    readonly sticky: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isFirstVisible: _angular_core.WritableSignal<boolean>;
     cols: _angular_core.Signal<readonly DataTableRowCellHeaderComponent[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableHeadComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableHeadComponent, "thead[luDataTableHead]", never, { "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, ["cols"], ["*"], true, never>;
 }
 
+interface LuDataTableTranslations {
+    move: string;
+}
+
 declare class DataTableRowComponent {
+    intl: LuDataTableTranslations;
     bodyRef: _lucca_front_ng_data_table.DataTableBodyComponent;
     headRef: _lucca_front_ng_data_table.DataTableHeadComponent;
     footRef: _lucca_front_ng_data_table.DataTableFootComponent;
     elementRef: ElementRef<Element>;
+    readonly cells: _angular_core.Signal<readonly BaseDataTableCell[]>;
     protected tableRef: _lucca_front_ng_data_table.DataTableComponent;
     selected: _angular_core.ModelSignal<boolean>;
-    selectedLabel: _angular_core.InputSignal<string>;
-    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectedLabel: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableRowComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableRowComponent, "tr[luDataTableRow]", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableRowComponent, "tr[luDataTableRow]", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["cells"], ["*"], true, never>;
 }
 
 declare class DataTableComponent {
     #private;
     tableRef: _angular_core.Signal<ElementRef<Element>>;
-    hover: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    layoutFixed: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    cellBorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    nested: _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>>>;
-    verticalAlign: _angular_core.InputSignal<"top" | "middle" | "bottom">;
-    rows: _angular_core.Signal<readonly DataTableRowComponent[]>;
-    header: _angular_core.Signal<DataTableHeadComponent>;
-    stickyHeader: _angular_core.Signal<boolean>;
-    cols: _angular_core.Signal<readonly _lucca_front_ng_data_table.DataTableRowCellHeaderComponent[]>;
-    classMods: _angular_core.Signal<{
+    readonly hover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly layoutFixed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly cellBorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nested: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly drag: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly 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>>>;
+    readonly verticalAlign: _angular_core.InputSignal<"top" | "middle" | "bottom">;
+    readonly rows: _angular_core.Signal<readonly DataTableRowComponent[]>;
+    readonly header: _angular_core.Signal<DataTableHeadComponent>;
+    readonly stickyHeader: _angular_core.Signal<boolean>;
+    readonly stickyColsStart: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly stickyColsEnd: _angular_core.InputSignalWithTransform<number, unknown>;
+    firstColumnVisibleAfterColsStart: _angular_core.WritableSignal<boolean>;
+    lastColumnVisibleBeforeColsEnd: _angular_core.WritableSignal<boolean>;
+    firstColumnVisible: _angular_core.WritableSignal<boolean>;
+    lastColumnVisible: _angular_core.WritableSignal<boolean>;
+    firstRowVisible: _angular_core.WritableSignal<boolean>;
+    lastRowVisible: _angular_core.WritableSignal<boolean>;
+    readonly cols: _angular_core.Signal<readonly _lucca_front_ng_data_table.DataTableRowCellHeaderComponent[]>;
+    readonly classMods: _angular_core.Signal<{
         dataTable: boolean;
         "mod-stickyHeader": boolean;
         "mod-hover": boolean;
@@ -85,12 +116,19 @@ declare class DataTableComponent {
         "mod-verticalAlignTop": boolean;
         "mod-verticalAlignMiddle": boolean;
         "mod-verticalAlignBottom": boolean;
+        "mod-columnsOverflow": number;
+        "is-firstColumnVisible": number | boolean;
+        "is-lastColumnVisible": number | boolean;
+        "is-firstColumnVisibleAfterColsStart": boolean;
+        "is-lastColumnVisibleBeforeColsEnd": boolean;
+        "is-firstRowVisible": boolean;
+        "is-lastRowVisible": boolean;
         "mod-layoutFixed": boolean;
     }>;
     scroll(): void;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableComponent, "lu-data-table", never, { "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "layoutFixed": { "alias": "layoutFixed"; "required": false; "isSignal": true; }; "cellBorder": { "alias": "cellBorder"; "required": false; "isSignal": true; }; "nested": { "alias": "nested"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; "isSignal": true; }; }, {}, ["rows", "header"], ["*", "[dataTablePagination]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableComponent, "lu-data-table", never, { "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "layoutFixed": { "alias": "layoutFixed"; "required": false; "isSignal": true; }; "cellBorder": { "alias": "cellBorder"; "required": false; "isSignal": true; }; "nested": { "alias": "nested"; "required": false; "isSignal": true; }; "drag": { "alias": "drag"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; "isSignal": true; }; "stickyColsStart": { "alias": "stickyColsStart"; "required": false; "isSignal": true; }; "stickyColsEnd": { "alias": "stickyColsEnd"; "required": false; "isSignal": true; }; }, {}, ["rows", "header"], ["*", "[dataTablePagination]"], true, never>;
 }
 
 export { DataTableBodyComponent, DataTableComponent, DataTableFootComponent, DataTableHeadComponent, DataTableRowCellComponent, DataTableRowCellHeaderComponent, DataTableRowComponent };

package/date/index.d.ts

@@ -16,6 +16,9 @@ declare class LuDateAdapterPipe<D> implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<LuDateAdapterPipe<any>, "luDate", true>;
 }
 
+/**
+ * @deprecated use `LuDateAdapterPipe` instead
+ */
 declare class LuDateAdapterModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDateAdapterModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateAdapterModule, never, [typeof LuDateAdapterPipe], [typeof LuDateAdapterPipe]>;
@@ -123,6 +126,9 @@ declare class LuCalendarInputComponent<D> extends ALuInput<D> implements Control
     static ɵcmp: i0.ɵɵComponentDeclaration<LuCalendarInputComponent<any>, "lu-calendar", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuCalendarInputComponent` instead
+ */
 declare class LuCalendarInputModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuCalendarInputModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuCalendarInputModule, never, [typeof LuCalendarInputComponent], [typeof LuCalendarInputComponent]>;
@@ -198,6 +204,9 @@ declare class LuDateSelectInputComponent<D> extends ALuSelectInputComponent<D> i
     static ɵcmp: i0.ɵɵComponentDeclaration<LuDateSelectInputComponent<any>, "lu-date-select", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "inputPlaceholder": { "alias": "placeholder"; "required": false; }; "hideClearer": { "alias": "hideClearer"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use `LuCalendarInputComponent, LuDatePickerComponent, LuDateInputDirective, LuDateAdapterPipe, LuDateSelectInputComponent` instead
+ */
 declare class LuDateModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDateModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateModule, never, [typeof LuCalendarInputComponent, typeof LuDatePickerComponent, typeof LuDateInputDirective, typeof LuDateAdapterPipe, typeof LuDateSelectInputComponent], [typeof LuCalendarInputComponent, typeof LuDatePickerComponent, typeof LuDateInputDirective, typeof LuDateAdapterPipe, typeof LuDateSelectInputComponent]>;
@@ -235,6 +244,9 @@ declare class LuHumanizeDatePipe implements PipeTransform {
 declare function getRelativeTime(date: number | Date, reference: number | Date, allowedUnits?: readonly LuRelativeTimeFormatUnit[]): LuRelativeTime;
 declare function relativeTimeTimer(date: Date | number, allowedUnits?: readonly LuRelativeTimeFormatUnit[]): Observable<LuRelativeTime>;
 
+/**
+ * @deprecated use `LuDateInputDirective` instead
+ */
 declare class LuDateInputModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDateInputModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateInputModule, never, [typeof LuDateInputDirective], [typeof LuDateInputDirective]>;
@@ -249,12 +261,18 @@ interface ILuDateInputLabel {
 }
 declare const luDateInputTranslations: LuTranslation<ILuDateInputLabel>;
 
+/**
+ * @deprecated use `LuDatePickerComponent` instead
+ */
 declare class LuDatePickerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDatePickerModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDatePickerModule, never, [typeof LuDatePickerComponent], [typeof LuDatePickerComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuDatePickerModule>;
 }
 
+/**
+ * @deprecated use `LuDateSelectInputComponent` instead
+ */
 declare class LuDateSelectInputModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDateSelectInputModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateSelectInputModule, never, [typeof LuDateSelectInputComponent], [typeof LuDateSelectInputComponent]>;

package/date2/index.d.ts

@@ -168,23 +168,23 @@ declare abstract class AbstractDateComponent {
     intl: Date2Translate;
     onTouched?: () => void;
     disabled: _angular_core.WritableSignal<boolean>;
-    format: _angular_core.InputSignal<DateFormat>;
+    readonly format: _angular_core.InputSignal<DateFormat>;
     protected inDateISOFormat: _angular_core.Signal<boolean>;
-    ranges: _angular_core.InputSignalWithTransform<DateRange[], readonly DateRange[] | readonly DateRangeInput[]>;
-    hideToday: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    hasTodayButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    clearBehavior: _angular_core.InputSignal<"clear" | "reset">;
-    mode: _angular_core.InputSignal<CalendarMode>;
-    hideWeekend: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    getCellInfo: _angular_core.InputSignal<(day: Date, mode: CalendarMode) => CellStatus>;
-    min: _angular_core.InputSignalWithTransform<Date, string | Date>;
-    max: _angular_core.InputSignalWithTransform<Date, string | Date>;
-    focusedDate: _angular_core.InputSignalWithTransform<Date, string | Date>;
+    readonly ranges: _angular_core.InputSignalWithTransform<DateRange[], readonly DateRange[] | readonly DateRangeInput[]>;
+    readonly hideToday: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hasTodayButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly clearBehavior: _angular_core.InputSignal<"clear" | "reset">;
+    readonly mode: _angular_core.InputSignal<CalendarMode>;
+    readonly hideWeekend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly getCellInfo: _angular_core.InputSignal<(day: Date, mode: CalendarMode) => CellStatus>;
+    readonly min: _angular_core.InputSignalWithTransform<Date, string | Date>;
+    readonly max: _angular_core.InputSignalWithTransform<Date, string | Date>;
+    readonly focusedDate: _angular_core.InputSignalWithTransform<Date, string | Date>;
     calendarMode: _angular_core.ModelSignal<CalendarMode>;
-    panelOpened: _angular_core.OutputEmitterRef<void>;
-    panelClosed: _angular_core.OutputEmitterRef<void>;
-    dateFormatLocalized: _angular_core.Signal<string>;
+    readonly panelOpened: _angular_core.OutputEmitterRef<void>;
+    readonly panelClosed: _angular_core.OutputEmitterRef<void>;
+    readonly dateFormatLocalized: _angular_core.Signal<string>;
     protected currentDate: _angular_core.WritableSignal<Date>;
     protected tabbableDate: _angular_core.WritableSignal<Date>;
     protected constructor();

package/department/index.d.ts

@@ -108,7 +108,7 @@ declare class LuDepartmentSelectInputComponent<D extends ILuDepartment = ILuDepa
 }
 
 /**
- * @deprecated
+ * @deprecated use `LuDepartmentFeederComponent, LuDepartmentSelectInputComponent` instead
  */
 declare class LuDepartmentSelectModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentSelectModule, never>;
@@ -116,18 +116,27 @@ declare class LuDepartmentSelectModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentSelectModule>;
 }
 
+/**
+ * @deprecated use `LuDepartmentFeederComponent, LuDepartmentSelectInputComponent` instead
+ */
 declare class LuDepartmentModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentModule, never, [typeof LuDepartmentSelectModule], [typeof LuDepartmentSelectModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentModule>;
 }
 
+/**
+ * @deprecated use `LuDepartmentFeederComponent` instead
+ */
 declare class LuDepartmentFeederModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentFeederModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentFeederModule, never, [typeof LuDepartmentFeederComponent], [typeof LuDepartmentFeederComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentFeederModule>;
 }
 
+/**
+ * @deprecated use `LuDepartmentSelectInputComponent` instead
+ */
 declare class LuDepartmentSelectInputModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentSelectInputModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentSelectInputModule, never, [typeof LuDepartmentSelectInputComponent], [typeof LuDepartmentSelectInputComponent]>;

package/divider/index.d.ts

@@ -4,10 +4,13 @@ import { OnChanges, ElementRef } from '@angular/core';
 declare class DividerComponent implements OnChanges {
     #private;
     content: ElementRef;
-    separatorRole: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    size: _angular_core.InputSignal<"M" | "S">;
-    withRole: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly separatorRole: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<"M" | "S">;
+    readonly withRole: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly classesConfig: _angular_core.Signal<{
+        [x: string]: boolean;
+    }>;
     ngOnChanges(): void;
     updateClasses(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;