@3kles/kles-material-table-v2 21.0.0

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

@@ -0,0 +1,1213 @@
+import * as i0 from '@angular/core';
+import { Signal, EventEmitter, Type, WritableSignal, 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 { MatTableDataSource, MatTable } from '@angular/material/table';
+import * as i4 from '@3kles/kles-material-dynamicforms';
+import { IKlesFieldConfig, GroupUiState, ArrayUiState, AbstractUiState } from '@3kles/kles-material-dynamicforms';
+import { SortHeaderArrowPosition, SortDirection, Sort, MatSort } from '@angular/material/sort';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { PageEvent, MatPaginatorIntl, MatPaginatorSelectConfig, MatPaginator } from '@angular/material/paginator';
+import { CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { DataSource } from '@angular/cdk/table';
+
+declare enum AlignCell {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}
+
+declare enum Span {
+    MAX = "max"
+}
+
+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>);
+interface IStyle {
+    ngStyle?: NgStyleInput;
+}
+interface IKlesHeaderFieldConfig {
+    field?: B;
+    label?: string;
+    tooltip?: string;
+    filterClearable?: boolean;
+    filterPredicate?: (value: any, filter: any) => boolean;
+    sortPredicate?: (data: any) => string | number;
+    style?: IStyle;
+}
+interface IKlesCellFieldConfig {
+    executeAfterChange?: (property?: string, row?: any, group?: FormGroup<any> | FormArray<any>) => Observable<any>;
+    style?: IStyle;
+    field: C;
+}
+interface IKlesFooterFieldConfig {
+    style?: IStyle;
+    field: B;
+}
+interface KlesExtraCellFieldConfig extends IKlesCellFieldConfig {
+    columnDef: string;
+    colspan?: number | Span;
+    rowspan?: number;
+}
+
+interface KlesColumnConfig {
+    columnDef: string;
+    sticky?: boolean;
+    stickyEnd?: boolean;
+    visible?: boolean;
+    visibleWhen?: Signal<boolean>;
+    disabled?: boolean;
+    ngClass?: any;
+    filterable?: boolean;
+    sortable?: boolean;
+    sortArrowPosition?: SortHeaderArrowPosition;
+    resizable?: boolean;
+    headerCell: IKlesHeaderFieldConfig;
+    cell: IKlesCellFieldConfig;
+    footerCell?: IKlesFooterFieldConfig;
+    align?: AlignCell;
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    canExpand?: boolean;
+    canExpandNode?: boolean;
+}
+
+interface ColumnApi {
+    setVisible(columnDef: string, visible: boolean): void;
+    toggleVisible(columnDef: string): void;
+    changeWidth(columnDef: string, options: {
+        width?: string;
+        maxWidth?: string;
+        minWidth?: string;
+    }): void;
+    setResizable(columnDef: string, resizable: boolean): any;
+    toggleResizable(columnDef: string): any;
+    setSticky(columnDef: string, options: {
+        sticky?: boolean;
+        stickyEnd?: boolean;
+    }): any;
+    columns(): KlesColumnConfig[];
+    setColumnPosition: (columnDef: any, position: number) => void;
+}
+
+interface FooterApi$1 {
+    show(): void;
+    hide(): void;
+}
+
+interface LoadingApi {
+    start(): any;
+    stop(): any;
+}
+
+interface PaginationApi {
+    setPageIndex(value: number): void;
+    setPageSize(value: number): void;
+    setPageSizeOptions(option: number[]): void;
+    firstPage(): void;
+    lastPage(): void;
+    enable(): void;
+    disable(): void;
+    page: EventEmitter<PageEvent>;
+}
+
+interface ScrollbarApi {
+    toTop(sb?: ScrollBehavior): void;
+    toLeft(sb?: ScrollBehavior): void;
+    toBottom(sb?: ScrollBehavior): void;
+    toRight(sb?: ScrollBehavior): void;
+    to(top: number, left: number, sb?: ScrollBehavior): void;
+    getTop(): number;
+}
+
+declare enum KlesSelectionModelState {
+    ENABLED = "enabled",
+    DISABLED = "disabled"
+}
+
+interface IKlesSelectionModel<T> {
+    select(value: T | T[], options?: {
+        emitEvent?: boolean;
+    }): void;
+    deselect(value: T | T[], options?: {
+        emitEvent?: boolean;
+    }): void;
+    toggle(value: T, options?: {
+        emitEvent?: boolean;
+    }): void;
+    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 {
+    selectionModel?: IKlesSelectionModel<FormGroup>;
+    count: Signal<number>;
+    disable(): void;
+    enable(): void;
+}
+
+interface SortApi {
+    setDirection(direction: SortDirection): void;
+    setActive(active: string): void;
+    sortChange(): EventEmitter<Sort>;
+}
+
+interface FormApi {
+    header: HeaderApi;
+    rows: RowsApi;
+    footer: FooterApi;
+}
+type Id = string | number;
+interface HeaderApi {
+    setValue(value: {
+        [key: string]: any;
+    }, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+    }): void;
+    patchValue(value: {
+        [key: string]: any;
+    }, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+    }): void;
+    get(): FormGroup;
+    clear(value?: any, options?: {
+        emitEvent?: boolean;
+    }): void;
+}
+interface FooterApi {
+    setValue(value: {
+        [key: string]: any;
+    }, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+    }): void;
+    patchValue(value: {
+        [key: string]: any;
+    }, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+    }): void;
+    get(): FormGroup;
+    clear(value?: any, options?: {
+        emitEvent?: boolean;
+    }): void;
+}
+interface RowsApi {
+    create(value: {
+        [key: string]: any;
+    }, index?: number, options?: {
+        emitEvent?: boolean;
+    }): FormGroup;
+    patch(_id: Id, value: {
+        [key: string]: any;
+    }, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+    }): FormGroup | undefined;
+    reset(_id: Id, value?: {
+        [key: string]: any;
+    }, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+        overwriteDefaultValue?: boolean;
+    }): void;
+    remove(_id: Id, options?: {
+        emitEvent?: boolean;
+    }): void;
+    list(): FormArray<FormGroup>;
+    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;
+};
+type Filters = Record<string, unknown>;
+type Query = {
+    pagination?: Pagination;
+    sort?: Sort;
+    filters?: Filters;
+};
+
+type LoaderLazyResult<R> = Observable<{
+    total: number;
+    items: R[];
+    header?: {
+        [key: string]: unknown;
+    };
+}>;
+type LoaderResult<R> = Observable<{
+    items: R[];
+}>;
+type LinesLoaderDef<T, R> = {
+    params?: () => Observable<T>;
+    loader: (params: T) => LoaderResult<R>;
+    hasChildren?: (parent: FormGroup, depth: number) => boolean;
+    childrens?: (params: T, parent: FormGroup, depth: number) => LoaderResult<R>;
+};
+type LinesLazyLoaderDef<T, R> = {
+    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>;
+};
+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 RowId = string | number;
+type SelectionConfigDef<T> = {
+    selectionMode?: boolean;
+    key?: string;
+    params?: () => Observable<T>;
+    select?: (params: T, row: FormGroup, selected: boolean, filters?: {
+        [key: string]: any;
+    }) => Observable<{
+        selected?: boolean;
+        count?: number;
+    }>;
+    selectAll?: (params: T, selected: boolean, filters: {
+        [key: string]: any;
+    }) => Observable<{
+        selected: boolean;
+        footer?: any;
+        count?: number;
+    }>;
+    /** optionnel */
+    /** pour indiquer le critère des lignes déja sélectionné */
+    isSelected?: (row: FormGroup) => boolean;
+    isDisabled?: (row: FormGroup) => boolean;
+};
+type Brand<K extends string> = {
+    readonly __brand: K;
+};
+type SelectionConfig<T> = SelectionConfigDef<T> & Brand<'SelectionConfig'>;
+declare const selectionConfig: <T>(l: SelectionConfigDef<T>) => SelectionConfig<T>;
+
+interface DefaultTableConfig {
+    id?: string;
+    columns: KlesColumnConfig[];
+    lineValidations?: ValidatorFn[];
+    lineAsyncValidations?: AsyncValidatorFn[];
+    footer?: boolean;
+    sortConfig?: Sort;
+}
+interface PaginatorConfig {
+    paginator?: boolean;
+    customMatPaginatorIntl?: Type<MatPaginatorIntl>;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showFirstLastButtons?: boolean;
+    selectConfig?: MatPaginatorSelectConfig;
+}
+interface InfiniteScrollConfig {
+    infinite?: boolean;
+}
+interface DragDropConfig {
+    enable?: boolean;
+    options?: {
+        autoScrollStep?: number;
+        connectedTo?: string[];
+        dragDisabled?: (row: FormGroup) => boolean;
+        dragPreview?: {
+            matchSize?: boolean;
+            component: Type<any>;
+        };
+        dragPlaceholder?: {
+            component: Type<any>;
+        };
+    };
+}
+interface DragDrop {
+    dragDropRows?: DragDropConfig;
+    drapDropColumns?: DragDropConfig;
+}
+type ExtraRowMode = 'expand' | 'always';
+interface ExtraRowConfig {
+    cells: KlesExtraCellFieldConfig[];
+    mode?: ExtraRowMode;
+    when?: (index: number, rowData: FormGroup) => boolean;
+}
+interface ExtraRow {
+    extraRows?: ExtraRowConfig[];
+    multiUnfold?: boolean;
+}
+type LoaderConfig<T, R> = {
+    lazy: true;
+    lines: LinesLazyLoader<T, R>;
+} | {
+    lazy?: false | undefined;
+    lines: LinesLoader<T, R>;
+};
+type Selection<T> = {
+    selection?: SelectionConfig<T>;
+};
+type Exclusive<T, U> = (T & {
+    [K in keyof U]?: never;
+}) | (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;
+    register(el: HTMLElement): void;
+    unregister(): 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>;
+}
+
+interface SortPayload {
+    active: string;
+    direction: SortDirection;
+}
+/**
+ * Payload de base pour une ligne.
+ *
+ * row      = le FormGroup de la ligne
+ * value    = row.value, donc sans les champs disabled
+ * rawValue = row.getRawValue(), donc avec les champs disabled
+ */
+interface RowPayload<TValue = unknown> {
+    row: FormGroup;
+    rowIndex: number;
+    value: Partial<TValue>;
+    rawValue: TValue;
+}
+interface RowMousePayload<TValue = unknown> extends RowPayload<TValue> {
+    event: MouseEvent;
+}
+/**
+ * Payload de base pour une cellule.
+ */
+interface CellPayload<TValue = unknown> {
+    row: FormGroup;
+    rowIndex: number;
+    columnDef: string;
+    control: AbstractControl | null;
+    value: unknown;
+    rawValue: TValue;
+    event?: Event;
+}
+interface CellMousePayload<TValue = unknown> extends CellPayload<TValue> {
+    event: MouseEvent;
+}
+interface CellValueChangePayload<TValue = unknown> {
+    row: FormGroup;
+    rowIndex: number;
+    columnDef: string;
+    control: AbstractControl;
+    previousValue: unknown;
+    currentValue: unknown;
+    value: Partial<TValue>;
+    rawValue: TValue;
+}
+/**
+ * Pagination.
+ */
+interface PageChangePayload {
+    pageIndex: number;
+    previousPageIndex?: number;
+    pageSize: number;
+    totalItems?: number;
+    sourceEvent?: PageEvent;
+}
+/**
+ * Filtres / recherche.
+ */
+interface FilterChangePayload {
+    filters: Record<string, unknown>;
+    changedFilter?: {
+        columnDef: string;
+        previousValue: unknown;
+        currentValue: unknown;
+    };
+}
+/**
+ * Colonnes.
+ */
+interface ColumnPayload {
+    columnDef: string;
+}
+interface ColumnResizePayload {
+    columnDef: string;
+    width: number;
+    previousWidth?: number;
+}
+interface ColumnOrderChangePayload {
+    previousIndex: number;
+    currentIndex: number;
+    columns: string[];
+}
+interface ColumnVisibilityChangePayload {
+    columnDef: string;
+    visible: boolean;
+    columns: string[];
+}
+/**
+ * Drag & drop.
+ */
+interface RowDropPayload<TValue = unknown> extends RowPayload<TValue> {
+    previousIndex: number;
+    currentIndex: number;
+    previousContainerId?: string;
+    currentContainerId?: string;
+}
+interface ColumnDropPayload {
+    columnDef: string;
+    previousIndex: number;
+    currentIndex: number;
+}
+/**
+ * Expansion / tree.
+ */
+interface ExpansionPayload<TValue = unknown> extends RowPayload<TValue> {
+    level?: number;
+}
+interface TreePayload<TValue = unknown> extends RowPayload<TValue> {
+    level: number;
+}
+/**
+ * Lazy loading.
+ */
+interface LoadSuccessPayload<TValue = unknown> {
+    rows: FormGroup[];
+    values: Partial<TValue>[];
+    rawValues: TValue[];
+    total?: number;
+}
+interface LoadErrorPayload {
+    error: unknown;
+    message?: string;
+}
+interface ValidationErrorPayload<TValue = unknown> {
+    row?: FormGroup;
+    rowIndex?: number;
+    columnDef?: string;
+    control?: AbstractControl | null;
+    value?: Partial<TValue>;
+    rawValue?: TValue;
+    errors: ValidationErrors | null;
+    controlsErrors?: Record<string, ValidationErrors | null | undefined>;
+}
+
+interface TableEventMap<TValue = unknown> {
+    /**
+     * row
+     */
+    rowClick: RowMousePayload<TValue>;
+    rowDoubleClick: RowMousePayload<TValue>;
+    rowContextMenu: RowMousePayload<TValue>;
+    rowMouseEnter: RowMousePayload<TValue>;
+    rowMouseLeave: RowMousePayload<TValue>;
+    rowCreate: RowPayload<TValue>;
+    rowUpdate: RowPayload<TValue>;
+    rowPatch: RowPayload<TValue>;
+    rowDelete: RowPayload<TValue>;
+    /**
+     * cell
+     */
+    cellClick: CellMousePayload<TValue>;
+    cellDoubleClick: CellMousePayload<TValue>;
+    cellContextMenu: CellMousePayload<TValue>;
+    cellValueChange: CellValueChangePayload<TValue>;
+    /**
+     * pagination
+     */
+    pageChange: PageChangePayload;
+    /**
+     * sort
+     */
+    sortChange: SortPayload;
+    /**
+     * filters
+     */
+    filterChange: FilterChangePayload;
+    /**
+     * columns
+     */
+    columnResize: ColumnResizePayload;
+    columnResizeStart: ColumnResizePayload;
+    columnResizeEnd: ColumnResizePayload;
+    columnOrderChange: ColumnOrderChangePayload;
+    columnVisibilityChange: ColumnVisibilityChangePayload;
+    /**
+     * Drag & drop
+     */
+    rowDragStart: RowPayload<TValue>;
+    rowDragMove: RowPayload<TValue>;
+    rowDragEnd: RowPayload<TValue>;
+    rowDrop: RowDropPayload<TValue>;
+    columnDragStart: ColumnPayload;
+    columnDragEnd: ColumnPayload;
+    columnDrop: ColumnDropPayload;
+    /**
+     * Expansion / tree
+     */
+    rowExpand: ExpansionPayload<TValue>;
+    rowCollapse: ExpansionPayload<TValue>;
+    rowToggleExpand: ExpansionPayload<TValue>;
+    expandAll: void;
+    collapseAll: void;
+    nodeExpand: TreePayload<TValue>;
+    nodeCollapse: TreePayload<TValue>;
+    nodeLoadChildren: TreePayload<TValue>;
+    nodeChildrenLoaded: TreePayload<TValue>;
+    /**
+     * Loading / lazy
+     */
+    loadStart: void;
+    loadSuccess: LoadSuccessPayload<TValue>;
+    loadError: LoadErrorPayload;
+    refresh: void;
+    /**
+     * Error / validation
+     */
+    rowValidationError: ValidationErrorPayload<TValue>;
+    cellValidationError: ValidationErrorPayload<TValue>;
+}
+
+type TableEventType<TValue = unknown> = keyof TableEventMap<TValue>;
+type TableEvent<TValue = unknown> = {
+    [K in keyof TableEventMap<TValue>]: TableEventMap<TValue>[K] extends void ? {
+        type: K;
+    } : {
+        type: K;
+        payload: TableEventMap<TValue>[K];
+    };
+}[keyof TableEventMap<TValue>];
+type TableEventPayload<TValue, K extends keyof TableEventMap<TValue>> = TableEventMap<TValue>[K];
+
+declare class EventsService<TValue = unknown> {
+    private readonly eventsSubject;
+    readonly events$: Observable<TableEvent<TValue>>;
+    /**
+     * Émet un event typé.
+     *
+     * Si l'event a un payload, TypeScript t'oblige à le fournir.
+     * Si l'event est void, TypeScript t'empêche de fournir un payload.
+     */
+    emit<K extends TableEventType<TValue>>(type: K, ...args: TableEventMap<TValue>[K] extends void ? [] : [payload: TableEventPayload<TValue, K>]): void;
+    /**
+     * Émet directement un event complet.
+     * Pratique si tu construis déjà l'objet ailleurs.
+     */
+    emitEvent(event: TableEvent<TValue>): void;
+    complete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventsService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventsService<any>>;
+}
+
+declare class ColumnsService {
+    private _columns;
+    private readonly eventsService;
+    displayedColumns: Signal<string[]> | undefined;
+    constructor(_columns: WritableSignal<KlesColumnConfig[]>, eventsService: EventsService);
+    register(): void;
+    get columns(): Signal<KlesColumnConfig[]>;
+    getVisible(): string[];
+    setVisible(columnDef: string, visible: boolean): void;
+    toggleVisible(columnDef: string): void;
+    changeWidth(columnDef: string, options: {
+        width?: string;
+        maxWidth?: string;
+        minWidth?: string;
+    }): void;
+    setResizable(columnDef: string, resizable: boolean): void;
+    toggleResizable(columnDef: string): void;
+    setSticky(columnDef: string, options: {
+        sticky?: boolean;
+        stickyEnd?: boolean;
+    }): void;
+    setColumnPosition(columnDef: string, position: number): void;
+    private updateColumn;
+    private setDisplayedColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsService, never>;
+    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();
+}
+
+declare class RowFormFactory {
+    createControl(field: IKlesFieldConfig, value?: any): {
+        control: AbstractControl;
+        ui: AbstractUiState;
+    };
+    createRow(fields: IKlesFieldConfig[], record: any, meta?: {
+        depth: number;
+        parentId: string | null;
+    }): {
+        formGroup: FormGroup;
+        groupUi: GroupUiState;
+    };
+    createRows(fields: IKlesFieldConfig[], records: any[], meta?: {
+        depth: number;
+        parentId: string | null;
+    }): {
+        formGroup: FormGroup;
+        groupUi: GroupUiState;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowFormFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RowFormFactory>;
+}
+
+declare class KlesForm {
+    private columnsService;
+    private rowFactory;
+    readonly form: FormGroup<{
+        header: FormGroup<{}>;
+        rows: FormArray<FormGroup<any>>;
+        footer: FormGroup<{}>;
+    }>;
+    readonly ui: GroupUiState<{
+        header: GroupUiState<{}>;
+        rows: ArrayUiState<any, any[], any[]>;
+        footer: GroupUiState<{}>;
+    }>;
+    readonly uiStore: WeakMap<AbstractControl<any, any, any>, AbstractUiState<any, any>>;
+    private readonly rowsStructureChangedSubject;
+    readonly rowsStructureChanged$: rxjs.Observable<void>;
+    constructor(columnsService: ColumnsService, rowFactory: RowFormFactory);
+    getRows(): FormArray<FormGroup>;
+    getUiRows(): ArrayUiState;
+    getUiHeader(): GroupUiState;
+    getUiFooter(): GroupUiState;
+    getHeader(): FormGroup;
+    getFooter(): FormGroup;
+    setRows(rows: {
+        formGroup: FormGroup;
+        groupUi: GroupUiState;
+    }[]): void;
+    private insertRowAndNotify;
+    insertRow(row: {
+        formGroup: FormGroup;
+        groupUi: GroupUiState;
+    }, index?: number, options?: {
+        emitEvent?: boolean;
+    }): {
+        formGroup: FormGroup;
+        groupUi: GroupUiState;
+    };
+    insertRows(rows: {
+        formGroup: FormGroup;
+        groupUi: GroupUiState;
+    }[], index?: number): void;
+    updateRow(_id: number | string, value: any, options?: {
+        emitEvent?: boolean;
+        onlySelf?: boolean;
+    }): FormGroup<any>;
+    resetRow(_id: number | string, value?: any, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+        overwriteDefaultValue?: boolean;
+    }): void;
+    deleteRowById(id: number | string, option?: {
+        emitEvent?: boolean;
+    }): void;
+    setHeaderControl(name: string, header: AbstractControl, options?: {
+        emitEvent?: false;
+    }): void;
+    setFooterControl(name: string, footer: AbstractControl, options?: {
+        emitEvent?: false;
+    }): void;
+    setHeaderUi(name: string, header: AbstractUiState): void;
+    setFooterUi(name: string, footer: AbstractUiState): void;
+    get rows(): FormGroup[];
+    init(): void;
+    private notifyRowsStructureChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KlesForm, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KlesForm>;
+}
+
+declare class CellValueChangeService {
+    private readonly eventsService;
+    private readonly destroyRef;
+    private readonly subscriptions;
+    constructor(eventsService: EventsService);
+    listen(visibleRows: FormGroup[], visibleColumns: string[]): void;
+    private getCellKey;
+    private subscribeToCell;
+    private unsubscribeInvisibleCells;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellValueChangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CellValueChangeService>;
+}
+
+declare class ValidationService {
+    private readonly eventsService;
+    private readonly destroyRef;
+    private readonly columnSubscriptions;
+    private readonly rowSubscriptions;
+    constructor(eventsService: EventsService);
+    listen(visibleRows: FormGroup[], visibleColumns: string[]): void;
+    private getCellKey;
+    private getRowKey;
+    private subscribeToCell;
+    private subscribeToRow;
+    private unsubscribe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationService>;
+}
+
+interface IDatasourceService {
+    get datasource(): IKlesDataSource;
+    register(): void;
+}
+declare class DatasourceService implements IDatasourceService {
+    private fm;
+    private columnsService;
+    private cellValueChangeService;
+    private validationService;
+    private _datasource;
+    private readonly destroyRef;
+    constructor(fm: KlesForm, columnsService: ColumnsService, cellValueChangeService: CellValueChangeService, validationService: ValidationService);
+    register(): void;
+    get datasource(): KlesDataSource;
+    private createDataSource;
+    private listen;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatasourceService>;
+}
+
+declare class PaginatorService {
+    private config;
+    protected paginatorStore: PaginatorStore | null;
+    private datasourceService;
+    private readonly eventsService;
+    private _paginator;
+    private _disabled;
+    private _pageChanged;
+    private readonly destroyRef;
+    constructor(config: PaginatorConfig, paginatorStore: PaginatorStore | null, datasourceService: IDatasourceService, eventsService: EventsService);
+    register(paginator: MatPaginator): void;
+    get paginator(): MatPaginator | undefined;
+    pageChanged(): EventEmitter<PageEvent>;
+    setPageIndex(index: number): void;
+    setPageSize(size: number): void;
+    setPageSizeOptions(option: number[]): void;
+    setlength(length: number): void;
+    firstPage(): void;
+    lastPage(): void;
+    disabled(): Signal<boolean>;
+    disable(): void;
+    enable(): void;
+    private setSizeIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorService, [{ optional: true; }, { optional: true; }, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginatorService>;
+}
+
+interface ISortService {
+    sort: MatSort;
+    register(s: MatSort): void;
+    setDirection(direction: SortDirection): void;
+    setActive(active: string): void;
+    sortChange(): EventEmitter<Sort>;
+}
+
+declare class FilterService {
+    private columnsService;
+    private datasourceService;
+    constructor(columnsService: ColumnsService, datasourceService: DatasourceService);
+    register(): void;
+    formatData(data: {
+        [key: string]: any;
+    }): any;
+    private createFilterPredicate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterService>;
+}
+
+interface ILoader<R> {
+    load(): Observable<{
+        total: number;
+        items: R[];
+        loading: boolean;
+        error?: any;
+        header?: any;
+    }>;
+    refresh(): void;
+}
+
+interface IHeaderService {
+    register(): void;
+}
+
+declare class ExpandedRowStore implements ITableStore {
+    private readonly _expandedIds$;
+    readonly expandedIds$: rxjs.Observable<Set<string>>;
+    reset(): void;
+    isExpanded(id: string): boolean;
+    get expandedIds(): ReadonlySet<string>;
+    expand(id: string): void;
+    collapse(id: string): void;
+    toggle(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandedRowStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExpandedRowStore>;
+}
+
+declare class ExtraRowService {
+    private _extraRowsConfig;
+    private expandedRowStore;
+    multiTemplateDataRows: Signal<boolean>;
+    rows: Signal<(ExtraRowConfig & {
+        displayedColumns: string[];
+    })[]>;
+    constructor(_extraRowsConfig: WritableSignal<ExtraRowConfig[]>, expandedRowStore: ExpandedRowStore);
+    extraColumns(): KlesExtraCellFieldConfig[];
+    private createWhen;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtraRowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExtraRowService>;
+}
+
+interface ILinesService {
+    register(): void;
+    total(): number;
+    loaded(): EventEmitter<void>;
+}
+
+interface ISelectionService {
+    key: string;
+    selectionMode: boolean;
+    register(): void;
+    selectionModel?: IKlesSelectionModel<FormGroup>;
+    count(): Signal<number>;
+    disable(): void;
+    enable(): void;
+}
+
+interface IScrollbarOrchestratorService {
+    register(): void;
+}
+
+interface ITableService {
+    readonly form: FormGroup<{
+        header: FormGroup<{}>;
+        rows: FormArray<FormGroup<any>>;
+        footer: FormGroup<{}>;
+    }>;
+    readonly ui: GroupUiState<{
+        header: GroupUiState;
+        rows: ArrayUiState<any, any, any>;
+        footer: GroupUiState;
+    }>;
+    klesForm: KlesForm;
+    trackBy: (_: number, row: FormGroup) => any;
+}
+
+declare class FooterService {
+    private _footer;
+    constructor(_footer: WritableSignal<boolean>);
+    get footer(): Signal<boolean>;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FooterService>;
+}
+
+declare class RenderService {
+    private _render;
+    render(): EventEmitter<void>;
+    forceRenderRows(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderService>;
+}
+
+declare class RowService {
+    private readonly eventsService;
+    constructor(eventsService: EventsService);
+    onClick(event: MouseEvent, row: FormGroup, rowIndex: number): void;
+    onDoubleClick(event: MouseEvent, row: FormGroup, rowIndex: number): void;
+    onContextMenu(event: MouseEvent, row: FormGroup, rowIndex: number): void;
+    onMouseEnter(event: MouseEvent, row: FormGroup, rowIndex: number): void;
+    onMouseLeave(event: MouseEvent, row: FormGroup, rowIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RowService>;
+}
+
+declare class CellService {
+    private readonly eventsService;
+    constructor(eventsService: EventsService);
+    onClick(event: MouseEvent, row: FormGroup, rowIndex: number, columnDef: string): void;
+    onDoubleClick(event: MouseEvent, row: FormGroup, rowIndex: number, columnDef: string): void;
+    onContextMenu(event: MouseEvent, row: FormGroup, rowIndex: number, columnDef: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CellService>;
+}
+
+declare class TableComponent implements ITable, OnInit, AfterViewInit, OnDestroy {
+    private readonly host;
+    private readonly connectorService;
+    private readonly loader;
+    private readonly datasourceService;
+    readonly tableService: ITableService;
+    readonly dragDropRowService: DragDropService;
+    private readonly selectionService;
+    readonly columnsService: ColumnsService;
+    readonly loadingService: LoadingService;
+    private readonly paginatorService;
+    private readonly scrollbarService;
+    private readonly footerService;
+    private readonly extraRowService;
+    private readonly renderService;
+    private readonly sortService;
+    private readonly filterService;
+    private readonly expandedRowStore;
+    private readonly rowFactory;
+    private readonly eventsService;
+    readonly rowService: RowService;
+    readonly cellService: CellService;
+    table: MatTable<FormGroup>;
+    matSort: MatSort;
+    formElemRef: ElementRef<HTMLElement>;
+    headerHeightPx: number;
+    scrollHeightPx: number;
+    footerHeightPx: number;
+    dataSource: IKlesDataSource;
+    columns: Signal<KlesColumnConfig[]>;
+    displayedColumns: Signal<string[]> | undefined;
+    showFooter: Signal<boolean>;
+    multiTemplateDataRows: Signal<boolean>;
+    extraRows: Signal<(ExtraRowConfig & {
+        displayedColumns: string[];
+    })[]>;
+    private ro?;
+    private readonly destroyRef;
+    private rafId?;
+    private _cleanup?;
+    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);
+    get isLoadingClass(): boolean;
+    get events(): EventsApi;
+    get form(): FormApi;
+    get scrollbar(): ScrollbarApi;
+    get column(): ColumnApi;
+    get pagination(): PaginationApi;
+    get selection(): SelectionApi;
+    get sort(): SortApi;
+    get loading(): LoadingApi;
+    get footer(): FooterApi$1;
+    get ui(): GroupUiState<{
+        header: GroupUiState;
+        rows: ArrayUiState;
+        footer: GroupUiState;
+    }>;
+    refresh(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    submit(): void;
+    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]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "kles-table", never, {}, {}, never, never, true, never>;
+}
+
+interface KlesTableApi {
+    refresh(): void;
+    get scrollbar(): ScrollbarApi;
+    get column(): ColumnApi;
+    get pagination(): PaginationApi | undefined;
+    get sort(): SortApi;
+    get loading(): LoadingApi;
+    get selection(): SelectionApi;
+    get form(): FormApi;
+    get footer(): FooterApi$1;
+    get ui(): GroupUiState<{
+        header: GroupUiState;
+        rows: ArrayUiState;
+        footer: GroupUiState;
+    }>;
+}
+
+declare class KlesTableComponent<TValue = unknown> implements OnInit, KlesTableApi {
+    private connectorService;
+    tableConfig: i0.InputSignal<KlesTableConfig>;
+    private readonly destroyRef;
+    tableEvent: EventEmitter<TableEvent<TValue>>;
+    rowClick: EventEmitter<RowMousePayload<TValue>>;
+    rowDoubleClick: EventEmitter<RowMousePayload<TValue>>;
+    rowContextMenu: EventEmitter<RowMousePayload<TValue>>;
+    cellClick: EventEmitter<CellMousePayload<TValue>>;
+    cellValueChange: EventEmitter<CellValueChangePayload<TValue>>;
+    constructor(connectorService: KlesTableConnectorService);
+    ngOnInit(): void;
+    get hostId(): string;
+    refresh(): void;
+    get scrollbar(): ScrollbarApi;
+    get column(): ColumnApi;
+    get pagination(): PaginationApi | undefined;
+    get sort(): SortApi;
+    get loading(): LoadingApi;
+    get selection(): SelectionApi;
+    get form(): FormApi;
+    get footer(): FooterApi$1;
+    get ui(): GroupUiState<{
+        header: GroupUiState;
+        rows: ArrayUiState;
+        footer: GroupUiState;
+    }>;
+    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>;
+}
+
+declare class KlesMaterialTableModule {
+    static declarations: any[][];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KlesMaterialTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KlesMaterialTableModule, never, [typeof i1.CommonModule, typeof TableComponent, typeof KlesTableComponent, typeof i4.KlesMaterialDynamicformsModule], [typeof KlesTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KlesMaterialTableModule>;
+}
+
+declare const SELECTION_CONFIG: InjectionToken<SelectionConfig<any>>;
+declare const LOADER_CONFIG: InjectionToken<LoaderConfig<any, any>>;
+declare const COLUMNS: InjectionToken<WritableSignal<KlesColumnConfig[]>>;
+declare const FOOTER: InjectionToken<WritableSignal<boolean>>;
+declare const EXTRA_ROWS: InjectionToken<WritableSignal<ExtraRowConfig[]>>;
+declare const ROW_DRAG_DROP: InjectionToken<DragDropService>;
+declare const DRAG_DROP_CONFIG: InjectionToken<DragDropService>;
+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 LINES_SERVICE: InjectionToken<ILinesService>;
+declare const DATASOURCE_SERVICE: InjectionToken<IDatasourceService>;
+declare const SELECTION_SERVICE: InjectionToken<ISelectionService>;
+declare const SORT_SERVICE: InjectionToken<ISortService>;
+declare const SCROLLBAR_ORCHESTRATOR_SERVICE: InjectionToken<IScrollbarOrchestratorService>;
+declare const TABLE_SERVICE: InjectionToken<ITableService>;
+
+export { AlignCell, COLUMNS, DATASOURCE_SERVICE, DRAG_DROP_CONFIG, EXTRA_ROWS, FOOTER, HEADER_SERVICE, KlesMaterialTableModule, KlesTableComponent, 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 { DefaultTableConfig, DragDrop, DragDropConfig, ExtraRow, ExtraRowConfig, ExtraRowMode, IKlesCellFieldConfig, IKlesFooterFieldConfig, IKlesHeaderFieldConfig, ITable, InfiniteScrollConfig, KlesColumnConfig, KlesExtraCellFieldConfig, KlesTableApi, KlesTableConfig, LinesLazyLoader, LinesLoader, LoaderConfig, LoaderLazyResult, LoaderResult, NgStyleInput, PaginatorConfig, RowId, Selection, SelectionConfig };