@3kles/kles-material-table-v2 21.4.2 → 21.6.0

package/types/3kles-kles-material-table-v2.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
-import { Signal, EventEmitter, Type, WritableSignal, OnInit, AfterViewInit, OnDestroy, ElementRef, InjectionToken } from '@angular/core';
+import { Signal, EventEmitter, Type, WritableSignal, Injector, OnInit, AfterViewInit, OnDestroy, ElementRef, InjectionToken } from '@angular/core';
 import * as i1 from '@angular/common';
-import { FormControlStatus, FormGroup, FormArray, ValidatorFn, AsyncValidatorFn, AbstractControl, ValidationErrors } from '@angular/forms';
+import { FormGroup, FormControlStatus, FormArray, ValidatorFn, AsyncValidatorFn, AbstractControl, ValidationErrors } from '@angular/forms';
 import { MatTableDataSource, MatTable } from '@angular/material/table';
 import * as i4 from '@3kles/kles-material-dynamicforms';
 import { IKlesFieldConfig, GroupUiState, ArrayUiState, AbstractUiState } from '@3kles/kles-material-dynamicforms';
@@ -10,6 +10,7 @@ import * as rxjs from 'rxjs';
 import { Observable, Subject } from 'rxjs';
 import { PageEvent, MatPaginatorIntl, MatPaginatorSelectConfig, MatPaginator } from '@angular/material/paginator';
 import { CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as _3kles_kles_material_table_v2 from '@3kles/kles-material-table-v2';
 import { DataSource } from '@angular/cdk/table';
 
 declare enum AlignCell {
@@ -24,7 +25,9 @@ declare enum Span {
 
 type B = Omit<IKlesFieldConfig, 'name'>;
 type C = Omit<IKlesFieldConfig, 'name' | 'value'>;
-type NgStyleInput = Record<string, any> | ((value?: any, status?: FormControlStatus, row?: Record<string, any>, rowStatus?: FormControlStatus) => Record<string, string | any>);
+type KlesStyleValue = string | number | null | undefined;
+type KlesStyleMap = Record<string, KlesStyleValue>;
+type NgStyleInput = KlesStyleMap | ((value?: unknown, status?: FormControlStatus, row?: Record<string, unknown>, rowStatus?: FormControlStatus) => KlesStyleMap);
 interface IStyle {
     ngStyle?: NgStyleInput;
 }
@@ -32,13 +35,16 @@ interface IKlesHeaderFieldConfig {
     field?: B;
     label?: string;
     tooltip?: string;
+    /** Displays the action used to clear this column's filter. */
     filterClearable?: boolean;
-    filterPredicate?: (value: any, filter: any) => boolean;
-    sortPredicate?: (data: any) => string | number;
+    /** Overrides the default filter predicate for this column. */
+    filterPredicate?: (value: unknown, filter: unknown) => boolean;
+    /** Overrides the default sorting value for this column. */
+    sortPredicate?: (data: FormGroup) => string | number;
     style?: IStyle;
 }
 interface IKlesCellFieldConfig {
-    executeAfterChange?: (property?: string, row?: any, group?: FormGroup<any> | FormArray<any>) => Observable<any>;
+    executeAfterChange?: (property?: string, row?: unknown, group?: FormGroup | FormArray) => Observable<unknown>;
     style?: IStyle;
     field?: C;
 }
@@ -53,6 +59,7 @@ interface KlesExtraCellFieldConfig extends IKlesCellFieldConfig {
 }
 
 type ColumnSeparatorStyle = 'solid' | 'dashed' | 'dotted' | 'double';
+type ColumnClass = string | string[] | Set<string> | Record<string, boolean | null | undefined>;
 interface ColumnSeparatorConfig {
     color?: string;
     width?: string;
@@ -69,7 +76,7 @@ interface KlesColumnConfig {
     visible?: boolean;
     visibleWhen?: Signal<boolean>;
     disabled?: boolean;
-    ngClass?: any;
+    ngClass?: ColumnClass;
     filterable?: boolean;
     sortable?: boolean;
     sortArrowPosition?: SortHeaderArrowPosition;
@@ -87,6 +94,7 @@ interface KlesColumnConfig {
 }
 
 interface ColumnApi {
+    getVisible(): string[];
     setVisible(columnDef: string, visible: boolean): void;
     toggleVisible(columnDef: string): void;
     changeWidth(columnDef: string, options: {
@@ -94,27 +102,30 @@ interface ColumnApi {
         maxWidth?: string;
         minWidth?: string;
     }): void;
-    setResizable(columnDef: string, resizable: boolean): any;
-    toggleResizable(columnDef: string): any;
+    setResizable(columnDef: string, resizable: boolean): void;
+    toggleResizable(columnDef: string): void;
     setSticky(columnDef: string, options: {
         sticky?: boolean;
         stickyEnd?: boolean;
-    }): any;
+    }): void;
     columns(): KlesColumnConfig[];
-    setColumnPosition: (columnDef: any, position: number) => void;
+    setColumnPosition(columnDef: string, position: number): void;
 }
 
-interface FooterApi$1 {
+interface FooterApi {
+    visible: Signal<boolean>;
     show(): void;
     hide(): void;
 }
 
 interface LoadingApi {
-    start(): any;
-    stop(): any;
+    active: Signal<boolean>;
+    start(): void;
+    stop(): void;
 }
 
 interface PaginationApi {
+    disabled: Signal<boolean>;
     setPageIndex(value: number): void;
     setPageSize(value: number): void;
     setPageSizeOptions(option: number[]): void;
@@ -126,6 +137,9 @@ interface PaginationApi {
 }
 
 interface ScrollbarApi {
+    setVisible(visible: boolean): void;
+    show(): void;
+    hide(): void;
     toTop(sb?: ScrollBehavior): void;
     toLeft(sb?: ScrollBehavior): void;
     toBottom(sb?: ScrollBehavior): void;
@@ -140,6 +154,21 @@ declare enum KlesSelectionModelState {
 }
 
 interface IKlesSelectionModel<T> {
+    readonly count: Signal<number>;
+    readonly changed: Observable<{
+        added?: T[];
+        removed?: T[];
+        count: number;
+        state: KlesSelectionModelState;
+    }>;
+    readonly stateChanged: Observable<KlesSelectionModelState>;
+    readonly selected: {
+        items: T[];
+        count: number;
+        state: KlesSelectionModelState;
+    };
+    readonly state: KlesSelectionModelState;
+    readonly selectionMode: boolean;
     select(value: T | T[], options?: {
         emitEvent?: boolean;
     }): void;
@@ -149,22 +178,15 @@ interface IKlesSelectionModel<T> {
     toggle(value: T, options?: {
         emitEvent?: boolean;
     }): void;
+    reset(values: T[], options?: {
+        emitEvent?: boolean;
+    }): void;
+    isSelected(value: T): boolean;
+    isMultipleSelection(): boolean;
     isEmpty(): boolean;
     hasValue(): boolean;
     disable(): void;
     enable(): void;
-    get selected(): {
-        items?: T[];
-        count: number;
-        state: KlesSelectionModelState;
-    };
-    get changed(): Observable<{
-        added?: T[];
-        removed?: T[];
-        count: number;
-        state: KlesSelectionModelState;
-    }>;
-    get state(): KlesSelectionModelState;
 }
 
 interface SelectionApi {
@@ -180,63 +202,51 @@ interface SortApi {
     sortChange(): EventEmitter<Sort>;
 }
 
-interface FormApi {
-    header: HeaderApi;
-    rows: RowsApi;
-    footer: FooterApi;
+type FormValue = Record<string, unknown>;
+type TableFormValue<TValue> = TValue extends object ? TValue : FormValue;
+interface FormApi<TRow = FormValue> {
+    header: HeaderFormApi;
+    rows: RowsFormApi<TRow>;
+    footer: FooterFormApi;
 }
 type Id = string | number;
-interface HeaderApi {
-    setValue(value: {
-        [key: string]: any;
-    }, options?: {
+interface HeaderFormApi {
+    setValue(value: FormValue, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
     }): void;
-    patchValue(value: {
-        [key: string]: any;
-    }, options?: {
+    patchValue(value: FormValue, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
     }): void;
     get(): FormGroup;
-    clear(value?: any, options?: {
+    clear(value?: unknown, options?: {
         emitEvent?: boolean;
     }): void;
 }
-interface FooterApi {
-    setValue(value: {
-        [key: string]: any;
-    }, options?: {
+interface FooterFormApi {
+    setValue(value: FormValue, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
     }): void;
-    patchValue(value: {
-        [key: string]: any;
-    }, options?: {
+    patchValue(value: FormValue, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
     }): void;
     get(): FormGroup;
-    clear(value?: any, options?: {
+    clear(value?: unknown, options?: {
         emitEvent?: boolean;
     }): void;
 }
-interface RowsApi {
-    create(value: {
-        [key: string]: any;
-    }, index?: number, options?: {
+interface RowsFormApi<TRow = FormValue> {
+    create(value: TRow, index?: number, options?: {
         emitEvent?: boolean;
     }): FormGroup;
-    patch(_id: Id, value: {
-        [key: string]: any;
-    }, options?: {
+    patch(_id: Id, value: Partial<TRow>, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
     }): FormGroup | undefined;
-    reset(_id: Id, value?: {
-        [key: string]: any;
-    }, options?: {
+    reset(_id: Id, value?: TRow, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
         overwriteDefaultValue?: boolean;
@@ -248,28 +258,6 @@ interface RowsApi {
     get(_id: Id): FormGroup | undefined;
 }
 
-interface EventsApi {
-    listen(): Observable<any>;
-}
-
-interface ITable {
-    scrollbar: ScrollbarApi;
-    column: ColumnApi;
-    pagination?: PaginationApi | undefined;
-    selection: SelectionApi;
-    sort: SortApi;
-    footer: FooterApi$1;
-    loading: LoadingApi;
-    form: FormApi;
-    events: EventsApi;
-    ui: GroupUiState<{
-        header: GroupUiState;
-        rows: ArrayUiState;
-        footer: GroupUiState;
-    }>;
-    refresh(): void;
-}
-
 type Pagination = {
     page: number;
     perPage: number;
@@ -281,6 +269,9 @@ type Query = {
     filters?: Filters;
 };
 
+type LoaderCallback<TArgs extends unknown[], TResult> = {
+    bivarianceHack(...args: TArgs): TResult;
+}['bivarianceHack'];
 type LoaderLazyResult<R> = Observable<{
     total: number;
     items: R[];
@@ -291,39 +282,42 @@ type LoaderLazyResult<R> = Observable<{
 type LoaderResult<R> = Observable<{
     items: R[];
 }>;
-type LinesLoaderDef<T, R> = {
+type LinesLoaderDef<T, R, C> = {
     params?: () => Observable<T>;
-    loader: (params: T) => LoaderResult<R>;
-    hasChildren?: (parent: FormGroup, depth: number) => boolean;
-    childrens?: (params: T, parent: FormGroup, depth: number) => LoaderResult<R>;
+    loader: LoaderCallback<[params: T], LoaderResult<R>>;
+    hasChildren?: LoaderCallback<[parent: FormGroup, depth: number], boolean>;
+    childrens?: LoaderCallback<[params: T, parent: FormGroup, depth: number], LoaderResult<C>>;
 };
-type LinesLazyLoaderDef<T, R> = {
+type LinesLazyLoaderDef<T, R, C> = {
     params?: () => Observable<T>;
-    loader: (params: T, query?: Query) => LoaderLazyResult<R>;
-    hasChildren?: (parent: FormGroup, depth: number) => boolean;
-    childrens?: (params: T, parent: FormGroup, depth: number, query?: Query) => LoaderLazyResult<R>;
+    loader: LoaderCallback<[params: T, query?: Query], LoaderLazyResult<R>>;
+    hasChildren?: LoaderCallback<[parent: FormGroup, depth: number], boolean>;
+    childrens?: LoaderCallback<[params: T, parent: FormGroup, depth: number, query?: Query], LoaderLazyResult<C>>;
 };
 type Brand$1<K extends string> = {
     readonly __brand: K;
 };
-type LinesLoader<T, R> = LinesLoaderDef<T, R> & Brand$1<'LinesLoader'>;
-type LinesLazyLoader<T, R> = LinesLazyLoaderDef<T, R> & Brand$1<'LinesLazyLoader'>;
-declare const linesLoader: <T, R>(l: LinesLoaderDef<T, R>) => LinesLoader<T, R>;
-declare const linesLazyLoader: <T, R>(l: LinesLazyLoaderDef<T, R>) => LinesLazyLoader<T, R>;
-
+type LinesLoader<T, R, C = R> = LinesLoaderDef<T, R, C> & Brand$1<'LinesLoader'>;
+type LinesLazyLoader<T, R, C = R> = LinesLazyLoaderDef<T, R, C> & Brand$1<'LinesLazyLoader'>;
+declare const linesLoader: <T, R, C = R>(l: LinesLoaderDef<T, R, C>) => LinesLoader<T, R, C>;
+declare const linesLazyLoader: <T, R, C = R>(l: LinesLazyLoaderDef<T, R, C>) => LinesLazyLoader<T, R, C>;
+
+type SelectionCallback<TArgs extends unknown[], TResult> = {
+    bivarianceHack(...args: TArgs): TResult;
+}['bivarianceHack'];
 type RowId = string | number;
 interface SelectionResponse {
     selected: boolean;
     count?: number;
 }
 interface SelectionAllResponse extends SelectionResponse {
-    footer?: any;
+    footer?: unknown;
 }
 interface SelectionState {
     loading: boolean;
     success: boolean;
     selected?: boolean;
-    footer?: any;
+    footer?: unknown;
     count?: number;
     error?: unknown;
 }
@@ -331,15 +325,20 @@ type SelectionConfigDef<T> = {
     selectionMode?: boolean;
     key?: string;
     params?: () => Observable<T>;
-    select?: (params: T, row: FormGroup, selected: boolean, filters?: {
-        [key: string]: any;
-    }) => Observable<SelectionResponse>;
-    selectAll?: (params: T, selected: boolean, filters?: {
-        [key: string]: any;
-    }) => Observable<SelectionAllResponse>;
-    /** optionnel */
-    /** pour indiquer le critère des lignes déja sélectionné */
+    select?: SelectionCallback<[
+        params: T,
+        row: FormGroup,
+        selected: boolean,
+        filters?: Record<string, unknown>
+    ], Observable<SelectionResponse>>;
+    selectAll?: SelectionCallback<[
+        params: T,
+        selected: boolean,
+        filters?: Record<string, unknown>
+    ], Observable<SelectionAllResponse>>;
+    /** Resolves the initial selected state of a row. */
     isSelected?: (row: FormGroup) => boolean;
+    /** Resolves whether selection must remain disabled for a row. */
     isDisabled?: (row: FormGroup) => boolean;
 };
 type Brand<K extends string> = {
@@ -365,7 +364,9 @@ interface EmptyStateConfig {
 interface DefaultTableConfig {
     id?: string;
     columns: KlesColumnConfig[];
+    /** Reserved for row-level validation configuration; not applied yet. */
     lineValidations?: ValidatorFn[];
+    /** Reserved for asynchronous row-level validation configuration; not applied yet. */
     lineAsyncValidations?: AsyncValidatorFn[];
     footer?: boolean;
     sortConfig?: Sort;
@@ -382,26 +383,49 @@ interface PaginatorConfig {
     selectConfig?: MatPaginatorSelectConfig;
 }
 interface InfiniteScrollConfig {
+    /** Reserved for the future infinite-scroll implementation. */
     infinite?: boolean;
 }
-interface DragDropConfig {
+interface DragDropRowChange<TValue = unknown> extends DragDropRowContext<TValue> {
+    previousIndex: number;
+    currentIndex: number;
+    previousContainerId?: string;
+    currentContainerId?: string;
+    parentId?: string | number | null;
+    depth?: number;
+    previousSiblingIndex?: number;
+    currentSiblingIndex?: number;
+    movedRows?: FormGroup[];
+    movedRawValues?: TValue[];
+}
+interface DragDropConfig<TValue = unknown> {
     enable?: boolean;
     options?: {
+        /** Restricts row dragging to the dedicated handle rendered in the first visible column. */
+        handleOnly?: boolean;
         autoScrollStep?: number;
         connectedTo?: string[];
         dragDisabled?: (row: FormGroup) => boolean;
+        drop?: (change: DragDropRowChange<TValue>) => Observable<unknown>;
         dragPreview?: {
             matchSize?: boolean;
-            component: Type<any>;
+            component: Type<unknown>;
         };
         dragPlaceholder?: {
-            component: Type<any>;
+            component: Type<unknown>;
         };
     };
 }
-interface DragDrop {
-    dragDropRows?: DragDropConfig;
-    drapDropColumns?: DragDropConfig;
+interface DragDropRowContext<TValue = unknown> {
+    row: FormGroup;
+    rowIndex: number;
+    value: Partial<TValue>;
+    rawValue: TValue;
+}
+interface DragDrop<TValue = unknown> {
+    dragDropRows?: DragDropConfig<TValue>;
+    /** Reserved for the future column drag-and-drop implementation. */
+    dragDropColumns?: DragDropConfig<TValue>;
 }
 type ExtraRowMode = 'expand' | 'always';
 interface ExtraRowConfig {
@@ -411,6 +435,7 @@ interface ExtraRowConfig {
 }
 interface ExtraRow {
     extraRows?: ExtraRowConfig[];
+    /** Allows several expandable data rows to remain open. Defaults to false. */
     multiUnfold?: boolean;
 }
 type LoaderConfig<T, R> = {
@@ -428,89 +453,9 @@ type Exclusive<T, U> = (T & {
 }) | (U & {
     [K in keyof T]?: never;
 });
-type KlesTableConfig<T = any, R = any> = DefaultTableConfig & Exclusive<PaginatorConfig, InfiniteScrollConfig> & LoaderConfig<T, R> & DragDrop & Selection<T> & ExtraRow;
-
-interface ITableStore {
-    reset(): void;
-}
-
-declare class PaginatorStore implements ITableStore {
-    protected config: PaginatorConfig;
-    private s;
-    page$: Observable<Pagination>;
-    constructor(config: PaginatorConfig);
-    setPage(v: Pagination): void;
-    snapshot(): Pagination;
-    reset(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorStore, [{ optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<PaginatorStore>;
-}
-
-declare abstract class DragDropBase {
-    protected config?: DragDropConfig;
-    constructor(config?: DragDropConfig);
-    get enable(): boolean;
-    get autoScrollStep(): number | true;
-    get connectedTo(): string[];
-    get sortPredicate(): (index: number, item: CdkDrag<number>) => boolean;
-    get previewComponent(): i0.Type<any>;
-    get previewMatchSize(): true;
-    abstract listDropped(event: CdkDragDrop<FormArray<FormGroup>>): void;
-}
-declare class DragDropService extends DragDropBase {
-    protected config?: DragDropConfig;
-    private paginatorStore?;
-    constructor(config?: DragDropConfig, paginatorStore?: PaginatorStore | null);
-    listDropped(event: CdkDragDrop<FormArray<FormGroup>>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropService, [{ optional: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropService>;
-}
-
-declare class ScrollbarService {
-    private element;
-    private default;
-    private readonly hiddenClass;
-    register(el: HTMLElement): void;
-    unregister(): void;
-    setScrollbarVisible(visible: boolean): void;
-    hideScrollbar(): void;
-    showScrollbar(): void;
-    toTop(sb?: ScrollBehavior): void;
-    toBottom(sb?: ScrollBehavior): void;
-    toLeft(sb?: ScrollBehavior): void;
-    toRight(sb?: ScrollBehavior): void;
-    to(top: number, left: number, sb?: ScrollBehavior): void;
-    getTop(): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollbarService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollbarService>;
-}
-
-declare class KlesTableConnectorService {
-    private _connected$;
-    private _table?;
-    readonly connected$: Observable<boolean>;
-    constructor();
-    connect(table: ITable): () => void;
-    get table(): ITable;
-    get scrollbar(): ScrollbarApi;
-    get column(): ColumnApi;
-    get pagination(): PaginationApi | undefined;
-    get sort(): SortApi;
-    get loading(): LoadingApi;
-    get selection(): SelectionApi;
-    get footer(): FooterApi$1;
-    get form(): FormApi;
-    get ui(): GroupUiState<{
-        header: GroupUiState;
-        rows: ArrayUiState;
-        footer: GroupUiState;
-    }>;
-    get events(): EventsApi;
-    refresh(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KlesTableConnectorService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<KlesTableConnectorService>;
-}
+type KlesTableConfig<T = unknown, R = unknown> = DefaultTableConfig & Exclusive<PaginatorConfig, InfiniteScrollConfig> & LoaderConfig<T, R> & DragDrop<R> & Selection<T> & ExtraRow;
 
+type AggregationType = 'sum' | 'avg' | 'min' | 'max' | 'count';
 interface SortPayload {
     active: string;
     direction: SortDirection;
@@ -531,6 +476,18 @@ interface RowPayload<TValue = unknown> {
 interface RowMousePayload<TValue = unknown> extends RowPayload<TValue> {
     event: MouseEvent;
 }
+interface RowActionClickPayload<TValue = unknown> extends RowPayload<TValue> {
+    actionKey: string;
+    event?: MouseEvent;
+}
+interface BulkActionClickPayload<TValue = unknown> {
+    actionKey: string;
+    selectedRows: FormGroup[];
+    selectedValues: Partial<TValue>[];
+    selectedRawValues: TValue[];
+    selectedCount: number;
+    event?: MouseEvent;
+}
 /**
  * Payload de base pour une cellule.
  */
@@ -556,6 +513,36 @@ interface CellValueChangePayload<TValue = unknown> {
     value: Partial<TValue>;
     rawValue: TValue;
 }
+/**
+ * Sélection.
+ */
+interface SelectionChangePayload<TValue = unknown> {
+    selectedRows: FormGroup[];
+    selectedValues: Partial<TValue>[];
+    selectedRawValues: TValue[];
+    selectedCount: number;
+    addedRows?: FormGroup[];
+    removedRows?: FormGroup[];
+    allSelected?: boolean;
+}
+interface SelectionErrorPayload<TValue = unknown> {
+    error: unknown;
+    requestedSelected: boolean;
+    previousSelected: boolean;
+    row?: FormGroup;
+    rowIndex?: number;
+    value?: Partial<TValue>;
+    rawValue?: TValue;
+}
+interface LoadingChangePayload {
+    loading: boolean;
+}
+interface VisibilityChangePayload {
+    visible: boolean;
+}
+interface EmptyStateChangePayload {
+    enabled: boolean;
+}
 /**
  * Pagination.
  */
@@ -577,6 +564,9 @@ interface FilterChangePayload {
         currentValue: unknown;
     };
 }
+interface GlobalSearchPayload {
+    search: string;
+}
 /**
  * Colonnes.
  */
@@ -601,11 +591,11 @@ interface ColumnVisibilityChangePayload {
 /**
  * Drag & drop.
  */
-interface RowDropPayload<TValue = unknown> extends RowPayload<TValue> {
-    previousIndex: number;
-    currentIndex: number;
-    previousContainerId?: string;
-    currentContainerId?: string;
+interface RowDropPayload<TValue = unknown> extends DragDropRowChange<TValue> {
+}
+interface RowDropErrorPayload<TValue = unknown> {
+    change: RowDropPayload<TValue>;
+    error: unknown;
 }
 interface ColumnDropPayload {
     columnDef: string;
@@ -620,6 +610,8 @@ interface ExpansionPayload<TValue = unknown> extends RowPayload<TValue> {
 }
 interface TreePayload<TValue = unknown> extends RowPayload<TValue> {
     level: number;
+    children?: FormGroup[];
+    childValues?: TValue[];
 }
 /**
  * Lazy loading.
@@ -634,6 +626,33 @@ interface LoadErrorPayload {
     error: unknown;
     message?: string;
 }
+/**
+ * État / vue.
+ */
+interface StateChangePayload {
+    columns: string[];
+    filters: Record<string, unknown>;
+    sort?: SortPayload;
+    pageIndex?: number;
+    pageSize?: number;
+}
+/**
+ * Footer / résumé.
+ */
+interface SummaryChangePayload {
+    columnDef: string;
+    value: unknown;
+    aggregation: AggregationType;
+}
+/**
+ * Validation.
+ */
+interface RowValidatePayload<TValue = unknown> extends RowPayload<TValue> {
+    valid: boolean;
+    invalid: boolean;
+    errors: ValidationErrors | null;
+    controlsErrors: Record<string, ValidationErrors | null>;
+}
 interface ValidationErrorPayload<TValue = unknown> {
     row?: FormGroup;
     rowIndex?: number;
@@ -665,6 +684,15 @@ interface TableEventMap<TValue = unknown> {
     cellDoubleClick: CellMousePayload<TValue>;
     cellContextMenu: CellMousePayload<TValue>;
     cellValueChange: CellValueChangePayload<TValue>;
+    /**
+     * Sélection
+     */
+    selectionChange: SelectionChangePayload<TValue>;
+    rowSelect: RowPayload<TValue>;
+    rowUnselect: RowPayload<TValue>;
+    selectAll: SelectionChangePayload<TValue>;
+    unselectAll: SelectionChangePayload<TValue>;
+    selectionError: SelectionErrorPayload<TValue>;
     /**
      * pagination
      */
@@ -692,17 +720,14 @@ interface TableEventMap<TValue = unknown> {
     rowDragMove: RowPayload<TValue>;
     rowDragEnd: RowPayload<TValue>;
     rowDrop: RowDropPayload<TValue>;
-    columnDragStart: ColumnPayload;
-    columnDragEnd: ColumnPayload;
-    columnDrop: ColumnDropPayload;
+    rowDropSuccess: RowDropPayload<TValue>;
+    rowDropError: RowDropErrorPayload<TValue>;
     /**
      * Expansion / tree
      */
     rowExpand: ExpansionPayload<TValue>;
     rowCollapse: ExpansionPayload<TValue>;
     rowToggleExpand: ExpansionPayload<TValue>;
-    expandAll: void;
-    collapseAll: void;
     nodeExpand: TreePayload<TValue>;
     nodeCollapse: TreePayload<TValue>;
     nodeLoadChildren: TreePayload<TValue>;
@@ -714,6 +739,12 @@ interface TableEventMap<TValue = unknown> {
     loadSuccess: LoadSuccessPayload<TValue>;
     loadError: LoadErrorPayload;
     refresh: void;
+    /**
+     * États d'affichage
+     */
+    loadingChange: LoadingChangePayload;
+    footerVisibilityChange: VisibilityChangePayload;
+    emptyStateChange: EmptyStateChangePayload;
     /**
      * Error / validation
      */
@@ -732,6 +763,56 @@ type TableEvent<TValue = unknown> = {
 }[keyof TableEventMap<TValue>];
 type TableEventPayload<TValue, K extends keyof TableEventMap<TValue>> = TableEventMap<TValue>[K];
 
+interface EventsApi<TValue = unknown> {
+    listen(): Observable<TableEvent<TValue>>;
+}
+
+interface EmptyStateApi {
+    enabled: Signal<boolean>;
+    enable(): void;
+    disable(): void;
+    toggle(): void;
+}
+
+interface RenderApi {
+    rows(): void;
+}
+
+type TreeNodeId = string | number;
+interface TreeApi {
+    readonly expandedIds: Signal<ReadonlySet<TreeNodeId>>;
+    readonly loadingIds: Signal<ReadonlySet<TreeNodeId>>;
+    isExpanded(id: TreeNodeId): boolean;
+    isLoading(id: TreeNodeId): boolean;
+    getChildren(id: TreeNodeId): FormGroup[];
+    getDescendants(id: TreeNodeId): FormGroup[];
+    expand(id: TreeNodeId): void;
+    collapse(id: TreeNodeId): void;
+    toggle(id: TreeNodeId): void;
+    collapseAll(): void;
+}
+
+interface ITable {
+    scrollbar: ScrollbarApi;
+    column: ColumnApi;
+    pagination?: PaginationApi | undefined;
+    selection: SelectionApi;
+    sort: SortApi;
+    footer: FooterApi;
+    loading: LoadingApi;
+    form: FormApi;
+    events: EventsApi;
+    emptyState: EmptyStateApi;
+    render: RenderApi;
+    tree: TreeApi;
+    ui: GroupUiState<{
+        header: GroupUiState;
+        rows: ArrayUiState;
+        footer: GroupUiState;
+    }>;
+    refresh(): void;
+}
+
 declare class EventsService<TValue = unknown> {
     private readonly eventsSubject;
     readonly events$: Observable<TableEvent<TValue>>;
@@ -783,36 +864,12 @@ declare class ColumnsService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ColumnsService>;
 }
 
-declare class LoadingService {
-    private _loading;
-    get loading(): i0.Signal<boolean>;
-    start(): void;
-    stop(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
-}
-
-interface IKlesDataSource extends DataSource<FormGroup> {
-    set data(data: any[]);
-    get paginator(): MatPaginator | null | undefined;
-    set paginator(paginator: MatPaginator | null | undefined);
-    get sort(): MatSort | null | undefined;
-    set sort(sort: MatSort | null | undefined);
-    get filter(): string | undefined;
-    set filter(f: string);
-    connect(): Observable<readonly FormGroup[]>;
-}
-
-declare class KlesDataSource extends MatTableDataSource<FormGroup, MatPaginator> implements IKlesDataSource {
-    constructor();
-}
-
 interface KlesRowContext<TSource = unknown> {
     source: TSource;
     _id: string | number;
     meta: {
         depth: number;
-        parentId: string | null;
+        parentId: string | number | null;
     };
 }
 
@@ -828,11 +885,11 @@ declare class RowFormFactory {
     };
     createRow<TSource extends Record<string, any>>(fields: IKlesFieldConfig[], record: TSource, meta?: {
         depth: number;
-        parentId: string | null;
+        parentId: string | number | null;
     }): KlesCreatedRow<TSource>;
     createRows<TSource extends Record<string, any>>(fields: IKlesFieldConfig[], records: TSource[], meta?: {
         depth: number;
-        parentId: string | null;
+        parentId: string | number | null;
     }): KlesCreatedRow<TSource>[];
     static ɵfac: i0.ɵɵFactoryDeclaration<RowFormFactory, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RowFormFactory>;
@@ -848,6 +905,13 @@ declare class RowContextStore {
     static ɵprov: i0.ɵɵInjectableDeclaration<RowContextStore>;
 }
 
+interface KlesRowMoveResult {
+    previousIndex: number;
+    currentIndex: number;
+    previousSiblingIndex: number;
+    currentSiblingIndex: number;
+    movedRows: FormGroup[];
+}
 declare class KlesForm {
     private columnsService;
     private rowFactory;
@@ -864,7 +928,9 @@ declare class KlesForm {
     }>;
     readonly uiStore: WeakMap<AbstractControl<any, any, any>, AbstractUiState<any, any>>;
     private readonly rowsStructureChangedSubject;
+    private readonly rowsReplacedSubject;
     readonly rowsStructureChanged$: rxjs.Observable<void>;
+    readonly rowsReplaced$: rxjs.Observable<void>;
     constructor(columnsService: ColumnsService, rowFactory: RowFormFactory, rowContextStore: RowContextStore);
     getRows(): FormArray<FormGroup>;
     getUiRows(): ArrayUiState;
@@ -881,6 +947,19 @@ declare class KlesForm {
         groupUi: GroupUiState;
     };
     insertRows(rows: KlesCreatedRow[], index?: number): void;
+    moveRow(row: FormGroup, targetRow: FormGroup): {
+        previousIndex: number;
+        currentIndex: number;
+    } | undefined;
+    canMoveSubtree(row: FormGroup, targetRow: FormGroup): boolean;
+    moveSubtree(row: FormGroup, targetRow: FormGroup): KlesRowMoveResult | undefined;
+    getSubtreeRows(row: FormGroup): FormGroup[];
+    private getSiblingIndex;
+    transferRowTo(target: KlesForm, row: FormGroup, targetRow?: FormGroup): {
+        previousIndex: number;
+        currentIndex: number;
+    } | undefined;
+    transferSubtreeTo(target: KlesForm, row: FormGroup, targetRow?: FormGroup): KlesRowMoveResult | undefined;
     updateRow(_id: number | string, value: any, options?: {
         emitEvent?: boolean;
         onlySelf?: boolean;
@@ -893,6 +972,9 @@ declare class KlesForm {
     deleteRowById(id: number | string, option?: {
         emitEvent?: boolean;
     }): void;
+    deleteRowsByIds(ids: ReadonlyArray<number | string>, option?: {
+        emitEvent?: boolean;
+    }): void;
     setHeaderControl(name: string, header: AbstractControl, options?: {
         emitEvent?: false;
     }): void;
@@ -908,6 +990,134 @@ declare class KlesForm {
     static ɵprov: i0.ɵɵInjectableDeclaration<KlesForm>;
 }
 
+declare abstract class DragDropBase {
+    protected config: DragDropConfig | undefined;
+    protected readonly eventsService: EventsService;
+    protected readonly klesForm: KlesForm;
+    protected readonly injector: Injector;
+    private static nextDropListId;
+    readonly dropListId: string;
+    constructor(config: DragDropConfig | undefined, eventsService: EventsService, klesForm: KlesForm, injector: Injector, tableId?: string);
+    get enable(): boolean;
+    get handleOnly(): boolean;
+    get autoScrollStep(): number;
+    get connectedTo(): string[];
+    get sortPredicate(): (index: number, item: CdkDrag<FormGroup>) => boolean;
+    get previewComponent(): i0.Type<unknown>;
+    get previewMatchSize(): boolean;
+    get placeholderComponent(): i0.Type<unknown>;
+    isDragDisabled(row: FormGroup): boolean;
+    componentInjector(row: FormGroup, rowIndex: number): Injector;
+    abstract listDropped(event: CdkDragDrop<KlesForm>): void;
+    rowDragStarted(row: FormGroup, rowIndex: number): void;
+    rowDragMoved(row: FormGroup, rowIndex: number): void;
+    rowDragEnded(row: FormGroup, rowIndex: number): void;
+    protected rowPayload(row: FormGroup, rowIndex: number): {
+        row: FormGroup<any>;
+        rowIndex: number;
+        value: any;
+        rawValue: any;
+    };
+    protected reorder(event: CdkDragDrop<KlesForm>): void;
+    protected transfer(event: CdkDragDrop<KlesForm>): void;
+    private handleDrop;
+    private toDropListId;
+}
+declare class DragDropService extends DragDropBase {
+    constructor(config: DragDropConfig | undefined, eventsService: EventsService, klesForm: KlesForm, injector: Injector, tableId?: string);
+    listDropped(event: CdkDragDrop<KlesForm>): void;
+}
+
+declare class ScrollbarService {
+    private element;
+    private default;
+    private readonly hiddenClass;
+    register(el: HTMLElement): void;
+    unregister(): void;
+    setScrollbarVisible(visible: boolean): void;
+    hideScrollbar(): void;
+    showScrollbar(): void;
+    toTop(sb?: ScrollBehavior): void;
+    toBottom(sb?: ScrollBehavior): void;
+    toLeft(sb?: ScrollBehavior): void;
+    toRight(sb?: ScrollBehavior): void;
+    to(top: number, left: number, sb?: ScrollBehavior): void;
+    getTop(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollbarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollbarService>;
+}
+
+declare class KlesTableConnectorService {
+    private _connected$;
+    private _table?;
+    readonly connected$: Observable<boolean>;
+    constructor();
+    connect(table: ITable): () => void;
+    get table(): ITable;
+    get scrollbar(): ScrollbarApi;
+    get column(): ColumnApi;
+    get pagination(): PaginationApi | undefined;
+    get sort(): SortApi;
+    get loading(): LoadingApi;
+    get selection(): SelectionApi;
+    get footer(): FooterApi;
+    get form(): _3kles_kles_material_table_v2.FormApi<_3kles_kles_material_table_v2.FormValue>;
+    get ui(): GroupUiState<{
+        header: GroupUiState;
+        rows: ArrayUiState;
+        footer: GroupUiState;
+    }>;
+    get events(): EventsApi;
+    get emptyState(): EmptyStateApi;
+    get render(): RenderApi;
+    get tree(): TreeApi;
+    refresh(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KlesTableConnectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KlesTableConnectorService>;
+}
+
+declare class LoadingService {
+    private readonly eventsService;
+    private _loading;
+    constructor(eventsService: EventsService);
+    get loading(): i0.Signal<boolean>;
+    start(): void;
+    stop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
+}
+
+interface ITableStore {
+    reset(): void;
+}
+
+declare class PaginatorStore implements ITableStore {
+    protected config: PaginatorConfig;
+    private s;
+    page$: Observable<Pagination>;
+    constructor(config: PaginatorConfig);
+    setPage(v: Pagination): void;
+    snapshot(): Pagination;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorStore, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginatorStore>;
+}
+
+interface IKlesDataSource extends DataSource<FormGroup> {
+    set data(data: unknown[]);
+    get paginator(): MatPaginator | null | undefined;
+    set paginator(paginator: MatPaginator | null | undefined);
+    get sort(): MatSort | null | undefined;
+    set sort(sort: MatSort | null | undefined);
+    get filter(): string | undefined;
+    set filter(f: string);
+    connect(): Observable<readonly FormGroup[]>;
+}
+
+declare class KlesDataSource extends MatTableDataSource<FormGroup, MatPaginator> implements IKlesDataSource {
+    constructor();
+}
+
 declare class CellValueChangeService {
     private readonly eventsService;
     private readonly destroyRef;
@@ -1013,8 +1223,8 @@ interface ILoader<R> {
         total: number;
         items: R[];
         loading: boolean;
-        error?: any;
-        header?: any;
+        error?: unknown;
+        header?: Record<string, unknown>;
     }>;
     refresh(): void;
 }
@@ -1023,15 +1233,18 @@ interface IHeaderService {
     register(): void;
 }
 
+type ExpandedRowId = string | number;
 declare class ExpandedRowStore implements ITableStore {
+    private readonly multiUnfold;
     private readonly _expandedIds$;
-    readonly expandedIds$: rxjs.Observable<Set<string>>;
+    readonly expandedIds$: rxjs.Observable<Set<ExpandedRowId>>;
+    constructor(multiUnfold?: boolean);
     reset(): void;
-    isExpanded(id: string): boolean;
-    get expandedIds(): ReadonlySet<string>;
-    expand(id: string): void;
-    collapse(id: string): void;
-    toggle(id: string): void;
+    isExpanded(id: ExpandedRowId): boolean;
+    get expandedIds(): ReadonlySet<ExpandedRowId>;
+    expand(id: ExpandedRowId): void;
+    collapse(id: ExpandedRowId): void;
+    toggle(id: ExpandedRowId): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExpandedRowStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ExpandedRowStore>;
 }
@@ -1044,7 +1257,7 @@ declare class ExtraRowService {
         displayedColumns: string[];
     })[]>;
     constructor(_extraRowsConfig: WritableSignal<ExtraRowConfig[]>, expandedRowStore: ExpandedRowStore);
-    extraColumns(): KlesExtraCellFieldConfig[];
+    extraFields(): IKlesFieldConfig[];
     private createWhen;
     static ɵfac: i0.ɵɵFactoryDeclaration<ExtraRowService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ExtraRowService>;
@@ -1062,6 +1275,8 @@ interface ISelectionService {
     selectionMode: boolean;
     register(): void;
     selectionModel?: IKlesSelectionModel<FormGroup>;
+    readonly loadingRows: Signal<ReadonlySet<FormGroup>>;
+    isLoading(row: FormGroup): boolean;
     count(): Signal<number>;
     disable(): void;
     enable(): void;
@@ -1088,7 +1303,8 @@ interface ITableService {
 
 declare class FooterService {
     private _footer;
-    constructor(_footer: WritableSignal<boolean>);
+    private readonly eventsService;
+    constructor(_footer: WritableSignal<boolean>, eventsService: EventsService);
     get footer(): Signal<boolean>;
     show(): void;
     hide(): void;
@@ -1136,10 +1352,11 @@ declare class KlesTableEmptyStateComponent {
 }
 
 declare class EmptyStateService {
+    private readonly eventsService;
     private readonly _enabled;
     readonly enabled: i0.Signal<boolean>;
     readonly component: Type<unknown>;
-    constructor(config: boolean | EmptyStateConfig | undefined);
+    constructor(config: boolean | EmptyStateConfig | undefined, eventsService: EventsService);
     enable(): void;
     disable(): void;
     toggle(): void;
@@ -1147,6 +1364,38 @@ declare class EmptyStateService {
     static ɵprov: i0.ɵɵInjectableDeclaration<EmptyStateService>;
 }
 
+declare class TreeService<T, R> {
+    private readonly loaderConfig;
+    private readonly loaderChildrensService;
+    private readonly fm;
+    private readonly columnsService;
+    private readonly rowFactory;
+    private readonly eventsService;
+    private readonly destroyRef;
+    private readonly expandedSubject;
+    readonly expandedIds$: rxjs.Observable<Set<TreeNodeId>>;
+    readonly expandedIds: i0.WritableSignal<ReadonlySet<TreeNodeId>>;
+    readonly loadingIds: i0.WritableSignal<ReadonlySet<TreeNodeId>>;
+    constructor();
+    toggle(id: TreeNodeId, group?: FormGroup, depth?: number): void;
+    expand(id: TreeNodeId, group?: FormGroup, depth?: number): void;
+    collapse(id: TreeNodeId, group?: FormGroup, depth?: number): void;
+    collapseAll(): void;
+    reset(): void;
+    isExpanded(id: TreeNodeId): boolean;
+    isLoading(id: TreeNodeId): boolean;
+    getChildren(id: TreeNodeId): FormGroup[];
+    getDescendants(id: TreeNodeId): FormGroup[];
+    hasChildren(group: FormGroup, depth: number): boolean;
+    private findRow;
+    private setExpanded;
+    private publishExpanded;
+    private setLoading;
+    private rowPayload;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeService<any, any>>;
+}
+
 type TableSection = 'header' | 'body' | 'footer';
 declare class TableComponent implements ITable, OnInit, AfterViewInit, OnDestroy {
     private readonly host;
@@ -1155,7 +1404,7 @@ declare class TableComponent implements ITable, OnInit, AfterViewInit, OnDestroy
     private readonly datasourceService;
     readonly tableService: ITableService;
     readonly dragDropRowService: DragDropService;
-    private readonly selectionService;
+    readonly selectionService: ISelectionService;
     readonly columnsService: ColumnsService;
     readonly loadingService: LoadingService;
     private readonly paginatorService;
@@ -1171,6 +1420,7 @@ declare class TableComponent implements ITable, OnInit, AfterViewInit, OnDestroy
     readonly rowService: RowService;
     readonly cellService: CellService;
     readonly emptyStateService: EmptyStateService;
+    private readonly treeService;
     table: MatTable<FormGroup>;
     matSort: MatSort;
     formElemRef: ElementRef<HTMLElement>;
@@ -1191,10 +1441,13 @@ declare class TableComponent implements ITable, OnInit, AfterViewInit, OnDestroy
     private rafId?;
     private _cleanup?;
     emptyStateComponent: typeof KlesTableEmptyStateComponent;
-    constructor(host: ElementRef<HTMLElement>, connectorService: KlesTableConnectorService, loader: ILoader<any>, datasourceService: IDatasourceService, tableService: ITableService, dragDropRowService: DragDropService, selectionService: ISelectionService, columnsService: ColumnsService, loadingService: LoadingService, paginatorService: PaginatorService, scrollbarService: ScrollbarService, footerService: FooterService, extraRowService: ExtraRowService, renderService: RenderService, sortService: ISortService, filterService: FilterService, expandedRowStore: ExpandedRowStore, rowFactory: RowFormFactory, eventsService: EventsService, rowService: RowService, cellService: CellService, emptyStateService: EmptyStateService);
+    constructor(host: ElementRef<HTMLElement>, connectorService: KlesTableConnectorService, loader: ILoader<unknown>, datasourceService: IDatasourceService, tableService: ITableService, dragDropRowService: DragDropService, selectionService: ISelectionService, columnsService: ColumnsService, loadingService: LoadingService, paginatorService: PaginatorService, scrollbarService: ScrollbarService, footerService: FooterService, extraRowService: ExtraRowService, renderService: RenderService, sortService: ISortService, filterService: FilterService, expandedRowStore: ExpandedRowStore, rowFactory: RowFormFactory, eventsService: EventsService, rowService: RowService, cellService: CellService, emptyStateService: EmptyStateService, treeService: TreeService<unknown, unknown>);
     get isLoadingClass(): boolean;
     get isEmptyClass(): boolean;
     get events(): EventsApi;
+    get emptyState(): EmptyStateApi;
+    get render(): RenderApi;
+    get tree(): TreeApi;
     get form(): FormApi;
     get scrollbar(): ScrollbarApi;
     get column(): ColumnApi;
@@ -1202,27 +1455,27 @@ declare class TableComponent implements ITable, OnInit, AfterViewInit, OnDestroy
     get selection(): SelectionApi;
     get sort(): SortApi;
     get loading(): LoadingApi;
-    get footer(): FooterApi$1;
+    get footer(): FooterApi;
     get ui(): GroupUiState<{
         header: GroupUiState;
         rows: ArrayUiState;
         footer: GroupUiState;
     }>;
     refresh(): void;
+    private rowEventPayload;
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    submit(): void;
     getColumnSeparator(column: KlesColumnConfig, section: TableSection): string | null;
     getStickyStartSeparator(column: KlesColumnConfig, section: TableSection): string | null;
     getStickyEndSeparator(column: KlesColumnConfig, section: TableSection): string | null;
     private getSeparatorStyle;
     private calculHeaderHeight;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, null, null, null, null, null, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, null, null, null, null, null, null, null]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "kles-table", never, {}, {}, never, never, true, never>;
 }
 
-interface KlesTableApi {
+interface KlesTableApi<TValue = unknown> {
     refresh(): void;
     get scrollbar(): ScrollbarApi;
     get column(): ColumnApi;
@@ -1230,8 +1483,12 @@ interface KlesTableApi {
     get sort(): SortApi;
     get loading(): LoadingApi;
     get selection(): SelectionApi;
-    get form(): FormApi;
-    get footer(): FooterApi$1;
+    get form(): FormApi<TableFormValue<TValue>>;
+    get footer(): FooterApi;
+    get emptyState(): EmptyStateApi;
+    get render(): RenderApi;
+    get tree(): TreeApi;
+    get events(): EventsApi<TValue>;
     get ui(): GroupUiState<{
         header: GroupUiState;
         rows: ArrayUiState;
@@ -1239,7 +1496,7 @@ interface KlesTableApi {
     }>;
 }
 
-declare class KlesTableComponent<TValue = unknown> implements OnInit, KlesTableApi {
+declare class KlesTableComponent<TValue = unknown> implements OnInit, KlesTableApi<TValue> {
     private connectorService;
     tableConfig: i0.InputSignal<KlesTableConfig>;
     private readonly destroyRef;
@@ -1247,8 +1504,25 @@ declare class KlesTableComponent<TValue = unknown> implements OnInit, KlesTableA
     rowClick: EventEmitter<RowMousePayload<TValue>>;
     rowDoubleClick: EventEmitter<RowMousePayload<TValue>>;
     rowContextMenu: EventEmitter<RowMousePayload<TValue>>;
+    rowMouseEnter: EventEmitter<RowMousePayload<TValue>>;
+    rowMouseLeave: EventEmitter<RowMousePayload<TValue>>;
+    rowDrop: EventEmitter<RowDropPayload<TValue>>;
+    rowDropSuccess: EventEmitter<RowDropPayload<TValue>>;
+    rowDropError: EventEmitter<RowDropErrorPayload<TValue>>;
     cellClick: EventEmitter<CellMousePayload<TValue>>;
+    cellDoubleClick: EventEmitter<CellMousePayload<TValue>>;
+    cellContextMenu: EventEmitter<CellMousePayload<TValue>>;
     cellValueChange: EventEmitter<CellValueChangePayload<TValue>>;
+    selectionChange: EventEmitter<SelectionChangePayload<TValue>>;
+    selectionError: EventEmitter<SelectionErrorPayload<TValue>>;
+    pageChange: EventEmitter<PageChangePayload>;
+    sortChange: EventEmitter<SortPayload>;
+    filterChange: EventEmitter<FilterChangePayload>;
+    loadError: EventEmitter<LoadErrorPayload>;
+    nodeExpand: EventEmitter<TreePayload<TValue>>;
+    nodeCollapse: EventEmitter<TreePayload<TValue>>;
+    nodeLoadChildren: EventEmitter<TreePayload<TValue>>;
+    nodeChildrenLoaded: EventEmitter<TreePayload<TValue>>;
     readonly elevationShadow: i0.Signal<string>;
     constructor(connectorService: KlesTableConnectorService);
     ngOnInit(): void;
@@ -1260,8 +1534,12 @@ declare class KlesTableComponent<TValue = unknown> implements OnInit, KlesTableA
     get sort(): SortApi;
     get loading(): LoadingApi;
     get selection(): SelectionApi;
-    get form(): FormApi;
-    get footer(): FooterApi$1;
+    get form(): FormApi<TableFormValue<TValue>>;
+    get footer(): FooterApi;
+    get emptyState(): EmptyStateApi;
+    get render(): RenderApi;
+    get events(): EventsApi<TValue>;
+    get tree(): TreeApi;
     get ui(): GroupUiState<{
         header: GroupUiState;
         rows: ArrayUiState;
@@ -1269,7 +1547,7 @@ declare class KlesTableComponent<TValue = unknown> implements OnInit, KlesTableA
     }>;
     private dispatchEvent;
     static ɵfac: i0.ɵɵFactoryDeclaration<KlesTableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KlesTableComponent<any>, "kles-dynamic-table", never, { "tableConfig": { "alias": "tableConfig"; "required": true; "isSignal": true; }; }, { "tableEvent": "tableEvent"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "rowContextMenu": "rowContextMenu"; "cellClick": "cellClick"; "cellValueChange": "cellValueChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KlesTableComponent<any>, "kles-dynamic-table", never, { "tableConfig": { "alias": "tableConfig"; "required": true; "isSignal": true; }; }, { "tableEvent": "tableEvent"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "rowContextMenu": "rowContextMenu"; "rowMouseEnter": "rowMouseEnter"; "rowMouseLeave": "rowMouseLeave"; "rowDrop": "rowDrop"; "rowDropSuccess": "rowDropSuccess"; "rowDropError": "rowDropError"; "cellClick": "cellClick"; "cellDoubleClick": "cellDoubleClick"; "cellContextMenu": "cellContextMenu"; "cellValueChange": "cellValueChange"; "selectionChange": "selectionChange"; "selectionError": "selectionError"; "pageChange": "pageChange"; "sortChange": "sortChange"; "filterChange": "filterChange"; "loadError": "loadError"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; "nodeLoadChildren": "nodeLoadChildren"; "nodeChildrenLoaded": "nodeChildrenLoaded"; }, never, never, true, never>;
 }
 
 declare class KlesMaterialTableModule {
@@ -1279,17 +1557,19 @@ declare class KlesMaterialTableModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<KlesMaterialTableModule>;
 }
 
-declare const SELECTION_CONFIG: InjectionToken<SelectionConfig<any>>;
-declare const LOADER_CONFIG: InjectionToken<LoaderConfig<any, any>>;
+declare const SELECTION_CONFIG: InjectionToken<SelectionConfig<unknown>>;
+declare const LOADER_CONFIG: InjectionToken<LoaderConfig<unknown, unknown>>;
 declare const COLUMNS: InjectionToken<WritableSignal<KlesColumnConfig[]>>;
 declare const FOOTER: InjectionToken<WritableSignal<boolean>>;
 declare const EXTRA_ROWS: InjectionToken<WritableSignal<ExtraRowConfig[]>>;
+declare const MULTI_UNFOLD: InjectionToken<boolean>;
 declare const ROW_DRAG_DROP: InjectionToken<DragDropService>;
-declare const DRAG_DROP_CONFIG: InjectionToken<DragDropService>;
+declare const DRAG_DROP_CONFIG: InjectionToken<DragDropConfig<unknown>>;
+declare const KLES_DRAG_DROP_ROW_CONTEXT: InjectionToken<DragDropRowContext<unknown>>;
 declare const PAGINATOR_CONFIG: InjectionToken<PaginatorConfig>;
 declare const SORT_CONFIG: InjectionToken<Sort>;
 declare const HEADER_SERVICE: InjectionToken<IHeaderService>;
-declare const LOADER_SERVICE: InjectionToken<ILoader<any>>;
+declare const LOADER_SERVICE: InjectionToken<ILoader<unknown>>;
 declare const LINES_SERVICE: InjectionToken<ILinesService>;
 declare const DATASOURCE_SERVICE: InjectionToken<IDatasourceService>;
 declare const SELECTION_SERVICE: InjectionToken<ISelectionService>;
@@ -1298,5 +1578,5 @@ declare const SCROLLBAR_ORCHESTRATOR_SERVICE: InjectionToken<IScrollbarOrchestra
 declare const TABLE_SERVICE: InjectionToken<ITableService>;
 declare const EMPTY_STATE_CONFIG: InjectionToken<boolean | EmptyStateConfig>;
 
-export { AlignCell, COLUMNS, DATASOURCE_SERVICE, DRAG_DROP_CONFIG, EMPTY_STATE_CONFIG, EXTRA_ROWS, FOOTER, HEADER_SERVICE, KlesMaterialTableModule, KlesTableComponent, KlesTableEmptyStateComponent, KlesTableIntl, LINES_SERVICE, LOADER_CONFIG, LOADER_SERVICE, PAGINATOR_CONFIG, ROW_DRAG_DROP, SCROLLBAR_ORCHESTRATOR_SERVICE, SELECTION_CONFIG, SELECTION_SERVICE, SORT_CONFIG, SORT_SERVICE, Span, TABLE_SERVICE, TableComponent, linesLazyLoader, linesLoader, selectionConfig };
-export type { ColumnSeparatorConfig, ColumnSeparatorStyle, DefaultTableConfig, DragDrop, DragDropConfig, EmptyStateConfig, ExtraRow, ExtraRowConfig, ExtraRowMode, IKlesCellFieldConfig, IKlesFooterFieldConfig, IKlesHeaderFieldConfig, ITable, InfiniteScrollConfig, KlesColumnConfig, KlesExtraCellFieldConfig, KlesTableApi, KlesTableConfig, LinesLazyLoader, LinesLoader, LoaderConfig, LoaderLazyResult, LoaderResult, NgStyleInput, PaginatorConfig, RowId, Selection, SelectionAllResponse, SelectionConfig, SelectionResponse, SelectionState, TableElevationLevel };
+export { AlignCell, COLUMNS, DATASOURCE_SERVICE, DRAG_DROP_CONFIG, EMPTY_STATE_CONFIG, EXTRA_ROWS, FOOTER, HEADER_SERVICE, KLES_DRAG_DROP_ROW_CONTEXT, KlesMaterialTableModule, KlesTableComponent, KlesTableEmptyStateComponent, KlesTableIntl, LINES_SERVICE, LOADER_CONFIG, LOADER_SERVICE, MULTI_UNFOLD, PAGINATOR_CONFIG, ROW_DRAG_DROP, SCROLLBAR_ORCHESTRATOR_SERVICE, SELECTION_CONFIG, SELECTION_SERVICE, SORT_CONFIG, SORT_SERVICE, Span, TABLE_SERVICE, TableComponent, linesLazyLoader, linesLoader, selectionConfig };
+export type { AggregationType, BulkActionClickPayload, CellMousePayload, CellPayload, CellValueChangePayload, ColumnApi, ColumnClass, ColumnDropPayload, ColumnOrderChangePayload, ColumnPayload, ColumnResizePayload, ColumnSeparatorConfig, ColumnSeparatorStyle, ColumnVisibilityChangePayload, DefaultTableConfig, DragDrop, DragDropConfig, DragDropRowChange, DragDropRowContext, EmptyStateApi, EmptyStateChangePayload, EmptyStateConfig, EventsApi, ExpansionPayload, ExtraRow, ExtraRowConfig, ExtraRowMode, FilterChangePayload, FooterApi, FooterFormApi, FormApi, FormValue, GlobalSearchPayload, HeaderFormApi, IKlesCellFieldConfig, IKlesFooterFieldConfig, IKlesHeaderFieldConfig, ITable, InfiniteScrollConfig, KlesColumnConfig, KlesExtraCellFieldConfig, KlesStyleMap, KlesStyleValue, KlesTableApi, KlesTableConfig, LinesLazyLoader, LinesLoader, LoadErrorPayload, LoadSuccessPayload, LoaderConfig, LoaderLazyResult, LoaderResult, LoadingApi, LoadingChangePayload, NgStyleInput, PageChangePayload, PaginationApi, PaginatorConfig, RenderApi, RowActionClickPayload, RowDropErrorPayload, RowDropPayload, RowId, RowMousePayload, RowPayload, RowValidatePayload, RowsFormApi, ScrollbarApi, Selection, SelectionAllResponse, SelectionApi, SelectionChangePayload, SelectionConfig, SelectionErrorPayload, SelectionResponse, SelectionState, SortApi, SortPayload, StateChangePayload, SummaryChangePayload, TableElevationLevel, TableEvent, TableEventMap, TableEventPayload, TableEventType, TableFormValue, TreeApi, TreeNodeId, TreePayload, ValidationErrorPayload, VisibilityChangePayload };