@vality/matez 19.0.1-pr-423-667df70.0

package/lib/components/progress/progress.component.d.ts

@@ -0,0 +1,9 @@
+import { Progressable } from '../../types/progressable';
+import * as i0 from "@angular/core";
+export declare class ProgressComponent implements Progressable {
+    progress: Progressable['progress'];
+    get mode(): "determinate" | "indeterminate" | undefined;
+    get value(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressComponent, "v-progress", never, { "progress": { "alias": "progress"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/progress/progress.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./progress.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/progress-bar";
+export declare class ProgressModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProgressModule, [typeof i1.ProgressComponent], [typeof i2.CommonModule, typeof i3.MatProgressBarModule], [typeof i1.ProgressComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProgressModule>;
+}

package/lib/components/progress/utils/get-progress-by-count.d.ts

@@ -0,0 +1 @@
+export declare function getProgressByCount(count: number, completedCount?: number): number;

package/lib/components/select-autocomplete/autocomplete-field/autocomplete-field.component.d.ts

@@ -0,0 +1,23 @@
+import { OnChanges } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ComponentChanges, FormControlSuperclass } from '../../../utils';
+import { Option } from '../types';
+import * as i0 from "@angular/core";
+export declare class AutocompleteFieldComponent<T> extends FormControlSuperclass<T> implements OnChanges {
+    options: Option<T>[];
+    label?: string;
+    hint?: string;
+    error?: string;
+    type: string;
+    mono: boolean;
+    required: boolean;
+    get hintText(): string | undefined;
+    options$: BehaviorSubject<Option<T>[]>;
+    selected$: import("rxjs").Observable<Option<T> | undefined>;
+    filteredOptions$: import("rxjs").Observable<Option<T>[]>;
+    ngOnChanges(changes: ComponentChanges<AutocompleteFieldComponent<T>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompleteFieldComponent<any>, "v-autocomplete-field", never, { "options": { "alias": "options"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "type": { "alias": "type"; "required": false; }; "mono": { "alias": "mono"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_mono: unknown;
+    static ngAcceptInputType_required: unknown;
+}

package/lib/components/select-autocomplete/autocomplete-field/autocomplete-field.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./autocomplete-field.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/autocomplete";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/icon";
+export declare class AutocompleteFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AutocompleteFieldModule, [typeof i1.AutocompleteFieldComponent], [typeof i2.CommonModule, typeof i3.MatInputModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof i5.MatAutocompleteModule, typeof i6.MatButtonModule, typeof i7.MatIconModule], [typeof i1.AutocompleteFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AutocompleteFieldModule>;
+}

package/lib/components/select-autocomplete/autocomplete-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './autocomplete-field.module';
+export * from './autocomplete-field.component';

package/lib/components/select-autocomplete/index.d.ts

@@ -0,0 +1,3 @@
+export * from './select-field';
+export * from './autocomplete-field';
+export * from './types';

package/lib/components/select-autocomplete/select-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './select-field.module';
+export * from './select-field.component';

package/lib/components/select-autocomplete/select-field/select-field.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import { MatFormFieldAppearance } from '@angular/material/form-field';
+import { FormControlSuperclass } from '../../../utils';
+import { Option } from '../types';
+import * as i0 from "@angular/core";
+export declare class SelectFieldComponent<T = unknown> extends FormControlSuperclass<T[]> {
+    options: Option<T>[];
+    searchChange: EventEmitter<string>;
+    appearance: MatFormFieldAppearance;
+    label?: string;
+    hint?: string;
+    error?: string;
+    progress: boolean;
+    externalSearch: boolean;
+    multiple: boolean;
+    required: boolean;
+    size?: 'small' | '';
+    searchStr: string;
+    get hintText(): string | undefined;
+    search: (term: string, item: Option<T>) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectFieldComponent<any>, "v-select-field", never, { "options": { "alias": "options"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "externalSearch": { "alias": "externalSearch"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "required": { "alias": "required"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "searchChange": "searchChange"; }, never, never, false, never>;
+    static ngAcceptInputType_externalSearch: unknown;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_required: unknown;
+}

package/lib/components/select-autocomplete/select-field/select-field.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./select-field.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@ng-matero/extensions/select";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/checkbox";
+export declare class SelectFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectFieldModule, [typeof i1.SelectFieldComponent], [typeof i2.CommonModule, typeof i3.MatInputModule, typeof i4.MtxSelectModule, typeof i5.FormsModule, typeof i5.ReactiveFormsModule, typeof i6.MatCheckboxModule], [typeof i1.SelectFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectFieldModule>;
+}

package/lib/components/select-autocomplete/types/index.d.ts

@@ -0,0 +1 @@
+export * from './option';

package/lib/components/select-autocomplete/types/option.d.ts

@@ -0,0 +1,6 @@
+export interface Option<T> {
+    value: T;
+    label: string;
+    description?: string;
+    type?: unknown;
+}

package/lib/components/select-autocomplete/utils/find-option-by-value.d.ts

@@ -0,0 +1,2 @@
+import { Option } from '../types';
+export declare function findOptionByValue<T>(options: Option<T>[], value: T): Option<T> | undefined;

package/lib/components/select-autocomplete/utils/get-hint-text.d.ts

@@ -0,0 +1,5 @@
+import { Option } from '../types';
+export declare function getHintText<T>(options: Option<T>[], selected: T[], hint?: string, opts?: {
+    multiple?: boolean;
+    showLabel?: boolean;
+}): string | undefined;

package/lib/components/select-autocomplete/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './search-options';
+export * from './find-option-by-value';

package/lib/components/select-autocomplete/utils/search-options.d.ts

@@ -0,0 +1,3 @@
+import { Option } from '../types';
+export declare function isSearchOption<T>(option: Option<T>, termLowerCase: string): boolean;
+export declare function searchOptions<T>(options: Option<T>[], term: string): Option<T>[];

package/lib/components/switch-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from './switch-button.module';
+export * from './switch-button.component';

package/lib/components/switch-button/switch-button.component.d.ts

@@ -0,0 +1,24 @@
+import { OnChanges } from '@angular/core';
+import { ComponentChanges, FormControlSuperclass } from '../../utils';
+import * as i0 from "@angular/core";
+export interface State<T = unknown> {
+    icon?: string;
+    label?: string;
+    value?: T;
+}
+export declare class SwitchButtonComponent<T = number> extends FormControlSuperclass<T> implements OnChanges {
+    states: State<T>[];
+    private hasChangeValue;
+    get index(): number;
+    get nextIndex(): number;
+    get value(): T;
+    get state(): State<T>;
+    get nextState(): State<T>;
+    get tooltip(): string;
+    change(): void;
+    ngOnChanges(changes: ComponentChanges<SwitchButtonComponent<T>>): void;
+    private getIndex;
+    private getValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchButtonComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchButtonComponent<any>, "v-switch-button", never, { "states": { "alias": "states"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/switch-button/switch-button.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./switch-button.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/tooltip";
+export declare class SwitchButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SwitchButtonModule, [typeof i1.SwitchButtonComponent], [typeof i2.CommonModule, typeof i3.MatButtonModule, typeof i4.MatIconModule, typeof i5.MatTooltipModule], [typeof i1.SwitchButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SwitchButtonModule>;
+}

package/lib/components/table/components/base-column.component.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { MatCellDef, MatColumnDef, MatFooterCellDef, MatHeaderCellDef, MatTable } from '@angular/material/table';
+import * as i0 from "@angular/core";
+export declare class BaseColumnComponent implements OnDestroy, OnInit {
+    name: import("@angular/core").InputSignal<string>;
+    table: MatTable<any>;
+    columnDef: import("@angular/core").Signal<MatColumnDef | undefined>;
+    cellDef: import("@angular/core").Signal<MatCellDef | undefined>;
+    headerCellDef: import("@angular/core").Signal<MatHeaderCellDef | undefined>;
+    footerCellDef: import("@angular/core").Signal<MatFooterCellDef | undefined>;
+    addedColumnDef?: MatColumnDef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private removeColumnDef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseColumnComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseColumnComponent, never, never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/table/components/customize/customize.component.d.ts

@@ -0,0 +1,17 @@
+import { DialogSuperclass } from '../../../dialog';
+import { Column, NormColumn } from '../../types';
+import * as i0 from "@angular/core";
+interface CustomizedColumn {
+    priority: number;
+    name: string;
+    hidden: boolean;
+}
+export declare class CustomizeComponent extends DialogSuperclass<CustomizeComponent, {
+    columns: NormColumn<object>[];
+}> {
+    columns: Column<CustomizedColumn>[];
+    data: CustomizedColumn[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomizeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CustomizeComponent, "v-customize", never, {}, {}, never, never, false, never>;
+}
+export {};

package/lib/components/table/components/dnd-column.component.d.ts

@@ -0,0 +1,7 @@
+import { BaseColumnComponent } from './base-column.component';
+import * as i0 from "@angular/core";
+export declare class DndColumnComponent extends BaseColumnComponent {
+    dragged: import("@angular/core").OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DndColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DndColumnComponent, "v-dnd-column", never, {}, { "dragged": "dragged"; }, never, never, true, never>;
+}

package/lib/components/table/components/infinity-scroll.directive.d.ts

@@ -0,0 +1,12 @@
+import { DestroyRef, ElementRef, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class InfinityScrollDirective implements OnInit {
+    private elementRef;
+    private dr;
+    vInfinityScroll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    vInfinityScrollMore: import("@angular/core").OutputEmitterRef<void>;
+    constructor(elementRef: ElementRef, dr: DestroyRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfinityScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityScrollDirective, "[vInfinityScroll]", never, { "vInfinityScroll": { "alias": "vInfinityScroll"; "required": false; "isSignal": true; }; }, { "vInfinityScrollMore": "vInfinityScrollMore"; }, never, never, true, never>;
+}

package/lib/components/table/components/no-records.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class NoRecordsComponent {
+    noRecords: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    progress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoRecordsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NoRecordsComponent, "v-no-records", never, { "noRecords": { "alias": "noRecords"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/table/components/select-column.component.d.ts

@@ -0,0 +1,21 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { DestroyRef, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { ArrayAttributeTransform, ComponentChanges } from '../../../utils';
+import { BaseColumnComponent } from './base-column.component';
+import * as i0 from "@angular/core";
+export declare class SelectColumnComponent<T> extends BaseColumnComponent implements OnInit, OnDestroy, OnChanges {
+    private dr;
+    selected: import("@angular/core").ModelSignal<any[]>;
+    data: import("@angular/core").InputSignalWithTransform<T[], ArrayAttributeTransform<any>>;
+    progress: import("@angular/core").InputSignal<number | boolean | null | undefined>;
+    selection: SelectionModel<T>;
+    isAllSelected$: import("rxjs").Observable<boolean>;
+    constructor(dr: DestroyRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: ComponentChanges<SelectColumnComponent<T>>): void;
+    toggleAllRows(): void;
+    private getIsAllSelected;
+    private updateSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectColumnComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectColumnComponent<any>, "v-select-column", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, never, never, true, never>;
+}

package/lib/components/table/components/table-actions.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TableActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableActionsComponent, "v-table-actions", never, {}, {}, never, ["*"], false, never>;
+}

package/lib/components/table/components/table-info-bar/table-info-bar.component.d.ts

@@ -0,0 +1,33 @@
+import { DestroyRef, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { NormColumn } from '../../types';
+import * as i0 from "@angular/core";
+export declare class TableInfoBarComponent<T extends object, C extends object> implements OnInit {
+    private dr;
+    progress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    hasMore: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    hasLoad: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    isPreload: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    noDownload: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    noToolbar: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    dataProgress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    columns: import("@angular/core").InputSignal<NormColumn<T, C>[]>;
+    size: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    preloadSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    count: import("@angular/core").InputSignal<number | null | undefined>;
+    filteredCount: import("@angular/core").InputSignal<number | null | undefined>;
+    selectedCount: import("@angular/core").InputSignal<number | null | undefined>;
+    filter: import("@angular/core").InputSignal<string>;
+    standaloneFilter: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    hasInputs: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    filterChange: import("@angular/core").OutputEmitterRef<string>;
+    filterControl: FormControl<string>;
+    downloadCsv: import("@angular/core").OutputEmitterRef<void>;
+    load: import("@angular/core").OutputEmitterRef<void>;
+    preload: import("@angular/core").OutputEmitterRef<void>;
+    countText: import("@angular/core").Signal<string>;
+    constructor(dr: DestroyRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableInfoBarComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableInfoBarComponent<any, any>, "v-table-info-bar", never, { "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "hasLoad": { "alias": "hasLoad"; "required": false; "isSignal": true; }; "isPreload": { "alias": "isPreload"; "required": false; "isSignal": true; }; "noDownload": { "alias": "noDownload"; "required": false; "isSignal": true; }; "noToolbar": { "alias": "noToolbar"; "required": false; "isSignal": true; }; "dataProgress": { "alias": "dataProgress"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "preloadSize": { "alias": "preloadSize"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "filteredCount": { "alias": "filteredCount"; "required": false; "isSignal": true; }; "selectedCount": { "alias": "selectedCount"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "standaloneFilter": { "alias": "standaloneFilter"; "required": false; "isSignal": true; }; "hasInputs": { "alias": "hasInputs"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; "downloadCsv": "downloadCsv"; "load": "load"; "preload": "preload"; }, never, ["v-table-inputs", "*"], false, never>;
+}

package/lib/components/table/components/table-inputs.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TableInputsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableInputsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableInputsComponent, "v-table-inputs", never, {}, {}, never, ["*"], false, never>;
+}

package/lib/components/table/components/table-progress-bar.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class TableProgressBarComponent {
+    progress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableProgressBarComponent, "v-table-progress-bar", never, { "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/table/consts.d.ts

@@ -0,0 +1,8 @@
+import { Sort } from '@angular/material/sort';
+export declare const DEFAULT_SORT: Sort;
+export declare const DEBOUNCE_TIME_MS = 500;
+export declare const DEFAULT_LOADED_LAZY_ROWS_COUNT = 3;
+export declare const COLUMN_DEFS: {
+    select: string;
+    drag: string;
+};

package/lib/components/table/index.d.ts

@@ -0,0 +1,10 @@
+export * from './table.module';
+export * from './utils/correct-priorities';
+export * from './utils/create-column';
+export * from './utils/cached-head-map';
+export * from './table.component';
+export * from './components/table-actions.component';
+export * from './components/table-inputs.component';
+export * from './types';
+export * from './presets';
+export * from './tree-data';

package/lib/components/table/presets/create-menu-column.d.ts

@@ -0,0 +1,6 @@
+import { Column } from '../types/column2';
+export declare const createMenuColumn: <T extends object>(getCellParams: (data: T, index: number) => import("@vality/matez").PossiblyAsync<{
+    items: import("../../value/components/menu-value.component").MenuItem[];
+}>, { isLazyCell, ...column }?: Partial<Column<T, object>> & {
+    isLazyCell?: boolean;
+}) => Column<T, object>;

package/lib/components/table/presets/index.d.ts

@@ -0,0 +1 @@
+export * from './create-menu-column';

package/lib/components/table/table.component.d.ts

@@ -0,0 +1,81 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { ChangeDetectorRef, DestroyRef, ElementRef, Injector, OnInit } from '@angular/core';
+import { MatSort, Sort } from '@angular/material/sort';
+import { MatTable } from '@angular/material/table';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { ArrayAttributeTransform } from '../../utils';
+import { TreeData } from './tree-data';
+import { Column, DragDrop, NormColumn, UpdateOptions } from './types';
+import { TableDataSource } from './utils/table-data-source';
+import { DisplayedData, DisplayedDataItem } from './utils/to-columns-data';
+import * as i0 from "@angular/core";
+export declare class TableComponent<T extends object, C extends object> implements OnInit {
+    private dr;
+    private injector;
+    private cdr;
+    data: import("@angular/core").InputSignalWithTransform<T[], ArrayAttributeTransform<T>>;
+    treeData: import("@angular/core").InputSignal<TreeData<T, C> | undefined>;
+    columns: import("@angular/core").InputSignalWithTransform<Column<T, C>[], ArrayAttributeTransform<Column<T, C>>>;
+    progress: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    hasMore: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    size: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    maxSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    noDownload: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    noToolbar: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    filter: import("@angular/core").ModelSignal<string>;
+    filter$: Observable<string>;
+    standaloneFilter: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    externalFilter: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    filteredSortData$: BehaviorSubject<DisplayedData<T, C> | null>;
+    displayedData$: Observable<DisplayedData<T, C>>;
+    displayedCount$: Observable<number>;
+    rowSelectable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    rowSelected: import("@angular/core").ModelSignal<DisplayedData<T, C>>;
+    sort: import("@angular/core").ModelSignal<Sort>;
+    sortComponent: MatSort;
+    rowDragDrop: import("@angular/core").InputSignalWithTransform<boolean | string[], boolean | string[]>;
+    rowDropped: import("@angular/core").OutputEmitterRef<DragDrop<DisplayedDataItem<T, C>>>;
+    dragDisabled: boolean;
+    update$: Subject<UpdateOptions>;
+    update: import("@angular/core").OutputRef<UpdateOptions>;
+    more: import("@angular/core").OutputEmitterRef<UpdateOptions>;
+    loadedLazyItems: WeakMap<DisplayedDataItem<T, C>, boolean>;
+    dataSource: TableDataSource<T, C>;
+    normColumns: import("@angular/core").Signal<NormColumn<T, C>[]>;
+    displayedNormColumns$: Observable<NormColumn<T, C>[]>;
+    columnsData$$: Observable<Map<DisplayedDataItem<T, C>, Map<NormColumn<T, C>, {
+        value: Observable<import("@vality/matez").Value | null>;
+        lazyValue?: Observable<import("@vality/matez").Value> | undefined;
+        isChild?: boolean | undefined;
+        isNextChild?: boolean | undefined;
+    }>>>;
+    columnsDataProgress$: BehaviorSubject<boolean>;
+    columnsData$: Observable<Map<DisplayedDataItem<T, C>, import("./utils/to-columns-data").ColumnData>>;
+    isPreload: import("@angular/core").WritableSignal<boolean>;
+    loadSize: import("@angular/core").Signal<number>;
+    hasAutoShowMore$: Observable<boolean>;
+    displayedColumns$: Observable<string[]>;
+    columnDefs: {
+        select: string;
+        drag: string;
+    };
+    scrollViewport: ElementRef;
+    table: MatTable<T>;
+    tableInputsContent: ElementRef;
+    tableRow: ElementRef;
+    constructor(dr: DestroyRef, injector: Injector, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    load(): void;
+    preload(): void;
+    showMore(): void;
+    downloadCsv(): void;
+    drop(event: CdkDragDrop<any>): void;
+    private generateCsvData;
+    private reload;
+    private updateSortFilter;
+    private reset;
+    private refreshTable;
+    private updateLoadedLazyItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any, any>, "v-table", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "treeData": { "alias": "treeData"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "noDownload": { "alias": "noDownload"; "required": false; "isSignal": true; }; "noToolbar": { "alias": "noToolbar"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "standaloneFilter": { "alias": "standaloneFilter"; "required": false; "isSignal": true; }; "externalFilter": { "alias": "externalFilter"; "required": false; "isSignal": true; }; "rowSelectable": { "alias": "rowSelectable"; "required": false; "isSignal": true; }; "rowSelected": { "alias": "rowSelected"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "rowDragDrop": { "alias": "rowDragDrop"; "required": false; "isSignal": true; }; }, { "filter": "filterChange"; "rowSelected": "rowSelectedChange"; "sort": "sortChange"; "rowDropped": "rowDropped"; "update": "update"; "more": "more"; }, ["tableInputsContent"], ["v-table-actions", "v-table-inputs"], false, never>;
+}

package/lib/components/table/table.module.d.ts

@@ -0,0 +1,34 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/customize/customize.component";
+import * as i2 from "./table.component";
+import * as i3 from "./components/table-info-bar/table-info-bar.component";
+import * as i4 from "./components/table-inputs.component";
+import * as i5 from "./components/table-actions.component";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/table";
+import * as i8 from "@angular/material/card";
+import * as i9 from "../value/value.component";
+import * as i10 from "./components/table-progress-bar.component";
+import * as i11 from "./components/no-records.component";
+import * as i12 from "../content-loading/content-loading.component";
+import * as i13 from "@angular/material/icon";
+import * as i14 from "@angular/material/tooltip";
+import * as i15 from "@angular/material/button";
+import * as i16 from "./components/infinity-scroll.directive";
+import * as i17 from "../value/components/value-list.component";
+import * as i18 from "./components/select-column.component";
+import * as i19 from "../progress/progress.module";
+import * as i20 from "@angular/material/sort";
+import * as i21 from "@angular/cdk/drag-drop";
+import * as i22 from "../dialog/dialog.module";
+import * as i23 from "../input-field/input-field.module";
+import * as i24 from "../actions/actions.module";
+import * as i25 from "@angular/material/badge";
+import * as i26 from "@angular/forms";
+import * as i27 from "../tag/tag.module";
+import * as i28 from "./components/dnd-column.component";
+export declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof i1.CustomizeComponent, typeof i2.TableComponent, typeof i3.TableInfoBarComponent, typeof i4.TableInputsComponent, typeof i5.TableActionsComponent], [typeof i6.CommonModule, typeof i7.MatTableModule, typeof i8.MatCardModule, typeof i9.ValueComponent, typeof i10.TableProgressBarComponent, typeof i11.NoRecordsComponent, typeof i12.ContentLoadingComponent, typeof i13.MatIcon, typeof i14.MatTooltip, typeof i15.MatIconButton, typeof i16.InfinityScrollDirective, typeof i17.ValueListComponent, typeof i18.SelectColumnComponent, typeof i19.ProgressModule, typeof i20.MatSortModule, typeof i15.MatButton, typeof i21.CdkDrag, typeof i21.CdkDropList, typeof i22.DialogModule, typeof i15.MatButtonModule, typeof i23.InputFieldModule, typeof i24.ActionsModule, typeof i25.MatBadgeModule, typeof i26.ReactiveFormsModule, typeof i27.TagModule, typeof i28.DndColumnComponent], [typeof i2.TableComponent, typeof i4.TableInputsComponent, typeof i5.TableActionsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}

package/lib/components/table/tree-data/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tree-data';
+export * from './tree-data-item-to-inline-data-item';

package/lib/components/table/tree-data/tree-data-item-to-inline-data-item.d.ts

@@ -0,0 +1,10 @@
+import { TreeDataItem } from './tree-data';
+export declare function treeDataItemToInlineDataItem<T extends object, C extends object>(item: TreeDataItem<T, C>): ({
+    child: C;
+} | {
+    value: T;
+    child: C;
+} | {
+    value: T;
+    child?: undefined;
+})[];

package/lib/components/table/tree-data/tree-data.d.ts

@@ -0,0 +1,10 @@
+export type TreeDataItem<T extends object, C extends object> = {
+    value: T;
+    children: C[];
+};
+export type TreeData<T extends object, C extends object> = TreeDataItem<T, C>[];
+export type TreeInlineDataItem<T extends object, C extends object> = {
+    value?: T;
+    child?: C;
+};
+export type TreeInlineData<T extends object, C extends object> = TreeInlineDataItem<T, C>[];

package/lib/components/table/types/column2.d.ts

@@ -0,0 +1,34 @@
+import { Observable } from 'rxjs';
+import { Async, PossiblyAsync } from '../../../utils';
+import { Value } from '../../value';
+export type Fn<R, P extends Array<unknown> = []> = (...args: P) => R;
+export type PossiblyFn<R, P extends Array<unknown> = []> = Fn<R, P> | R;
+export type CellFnArgs<T extends object> = [data: T, index: number];
+interface ColumnParams {
+    sticky?: 'start' | 'end';
+    style?: Record<string, unknown>;
+}
+export type CellValue = 'string' | Value;
+export interface Column<T extends object, C extends object = object> extends ColumnParams {
+    field: string;
+    header?: PossiblyAsync<Partial<Value> | string>;
+    cell?: PossiblyFn<PossiblyAsync<CellValue>, CellFnArgs<T>>;
+    lazyCell?: PossiblyFn<Async<CellValue>, CellFnArgs<T>>;
+    child?: PossiblyFn<PossiblyAsync<CellValue>, CellFnArgs<C>>;
+    hidden?: PossiblyAsync<boolean>;
+    sort?: PossiblyAsync<boolean>;
+}
+export declare function normalizePossiblyFn<R, P extends Array<unknown>>(fn: PossiblyFn<R, P>): Fn<R, P>;
+export declare function normalizeCell<T extends object, C extends object>(field: string, cell: Column<T, C>['cell'], hasChild?: boolean): Fn<Observable<Value>, CellFnArgs<T>>;
+export declare class NormColumn<T extends object, C extends object = object> {
+    field: string;
+    header: Observable<Value>;
+    cell?: Fn<Observable<Value>, CellFnArgs<T>>;
+    lazyCell?: Fn<Observable<Value>, CellFnArgs<T>>;
+    child?: Fn<Observable<Value>, CellFnArgs<C>>;
+    hidden: Observable<boolean>;
+    sort: Observable<boolean | null>;
+    params: ColumnParams;
+    constructor({ field, header, cell, child, hidden, sort, lazyCell, ...params }: Column<T, C>, commonParams?: ColumnParams);
+}
+export {};

package/lib/components/table/types/drag-drop.d.ts

@@ -0,0 +1,10 @@
+import { Sort } from '@angular/material/sort';
+export interface DragDrop<T> {
+    item: T;
+    previousIndex: number;
+    currentIndex: number;
+    previousData: T[];
+    currentDataIndex: number;
+    currentData: T[];
+    sort: Sort;
+}

package/lib/components/table/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './column2';
+export * from './update-options';
+export * from './drag-drop';

package/lib/components/table/types/update-options.d.ts

@@ -0,0 +1,3 @@
+export type UpdateOptions = {
+    size: number;
+};

package/lib/components/table/utils/cached-head-map.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function cachedHeadMap<T extends object, R>(fn: (el: T, idx: number) => R): (src$: Observable<T[] | undefined>) => Observable<R[]>;

package/lib/components/table/utils/correct-priorities.d.ts

@@ -0,0 +1,5 @@
+export declare function correctPriorities(priorities: number[], opts?: {
+    step: number;
+    maxStep: number;
+    start: number;
+}): number[];

package/lib/components/table/utils/create-column.d.ts

@@ -0,0 +1,6 @@
+import { PossiblyAsync } from '../../../utils';
+import { Value } from '../../value';
+import { CellFnArgs, Column } from '../types';
+export declare function createColumn<P, A extends object>(createCell: (cellParams: P, ...args: CellFnArgs<A>) => PossiblyAsync<Value>, columnObject?: Partial<Column<A>>): <T extends A>(getCellParams: (...args: CellFnArgs<T>) => PossiblyAsync<P>, { isLazyCell, ...column }?: Partial<Column<T>> & {
+    isLazyCell?: boolean;
+}) => Column<T>;

package/lib/components/table/utils/create-intersection-observer.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function createIntersectionObserver(el: HTMLElement): Observable<IntersectionObserverEntry>;