@den4ik92/ng2-smart-table 19.6.47 → 20.0.0

package/index.d.ts

@@ -1,5 +1,626 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@den4ik92/ng2-smart-table" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { Signal, InputSignal, OutputEmitterRef, OnDestroy, OnInit, EventEmitter, OnChanges, AfterViewInit, ViewContainerRef, TemplateRef, SimpleChange } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { Subject, Observable, Subscription } from 'rxjs';
+import { UntypedFormControl } from '@angular/forms';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { HttpParams } from '@angular/common/http';
+
+declare abstract class DataSource<T extends BaseDataType = any> {
+    protected readonly onChangedSource: Subject<SmartTableOnChangedEvent>;
+    protected readonly sortConf: _angular_core.WritableSignal<SmartTableSortItem | null>;
+    protected readonly filters: _angular_core.WritableSignal<SmartTableFilterItem[]>;
+    readonly pagingConf: _angular_core.WritableSignal<SmartTablePagerSettings>;
+    protected readonly data: _angular_core.WritableSignal<T[]>;
+    /**
+     * return all elements
+     */
+    abstract getAll(): Promise<T[]>;
+    abstract count(): number;
+    readonly getSort: Signal<SmartTableSortItem | null>;
+    readonly getFilters: Signal<SmartTableFilterItem[]>;
+    refresh(): void;
+    columnRefresh(): void;
+    onChanged(): Observable<SmartTableOnChangedEvent>;
+    prepend(element: T): Promise<true>;
+    appendMany(elements: T[]): Promise<true>;
+    add(element: T): Promise<true>;
+    remove(element: T): Promise<true>;
+    update(oldItem: T, newItem: T): Promise<true>;
+    empty(): Promise<true>;
+    setSort(conf: SmartTableSortItem | null, doEmit?: boolean): void;
+    addFilter(newFilter: SmartTableFilterItem, doEmit?: boolean): Promise<void>;
+    setFilters(newFilters: SmartTableFilterItem[], doEmit?: boolean): void;
+    setPaging(page: number | undefined, perPage: number, doEmit?: boolean): void;
+    setPage(page: number, doEmit?: boolean): void;
+    emitOnChanged(eventData: SmartTableOnChangedEventToEmit, newElements?: T[]): void;
+    /**
+     * @param difference number to plus total
+     * @example -2 or 2
+     */
+    private updateTotal;
+}
+
+declare class Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value?: T) => void;
+    reject: (reason?: string) => void;
+    constructor();
+}
+
+interface SelectOption {
+    title: string;
+    value: any;
+}
+type BaseDataType = Record<string, any>;
+interface ViewCell<V = any, R extends BaseDataType = BaseDataType> {
+    value: InputSignal<V>;
+    rowData: InputSignal<R>;
+}
+type ActionPosition = 'left' | 'right';
+interface ColumnPositionState {
+    key: string;
+    title: string;
+    hide: boolean;
+    moveDisabled: boolean;
+}
+interface SmartTableSettings<T extends BaseDataType = any> {
+    selectMode?: 'single' | 'multi';
+    mode?: 'inline' | 'external';
+    resetSortOnThirdClick?: boolean;
+    columnSort?: {
+        /**
+         * @description  save table columns state in local storage and use it after init
+         */
+        stateStorageKey?: string;
+        /**
+         * @description delay to start move column card
+         * @default 0
+         */
+        dragDelay?: number;
+        active: boolean;
+    };
+    hideHeader?: boolean;
+    hideSubHeader?: boolean;
+    /**
+     * @description Breakpoint for mobile table width in pixels if table width is less than this value, table will be displayed in mobile mode
+     * @example 768
+     */
+    tableWidthMobileBreakpoint?: number;
+    actions?: SmartTableAction<T> | false;
+    actionsPosition?: ActionPosition;
+    filter?: {
+        inputClass: string;
+    };
+    edit?: {
+        inputClass?: string;
+        editButtonContent?: string;
+        saveButtonContent?: string;
+        cancelButtonContent?: string;
+        confirmSave?: boolean;
+        hasPermissionFunction?: (row: T) => boolean;
+    } | false;
+    add?: {
+        inputClass?: string;
+        addButtonContent?: string;
+        createButtonContent?: string;
+        cancelButtonContent?: string;
+        confirmCreate?: boolean;
+    } | false;
+    delete?: {
+        deleteButtonContent?: string;
+        confirmDelete?: boolean;
+        hasPermissionFunction?: (row: T) => boolean;
+    } | false;
+    attr?: {
+        id?: string;
+        class?: string;
+    };
+    noDataMessage?: string;
+    columns: SmartTableColumnSettings<T>[];
+    pager?: Omit<SmartTablePagerSettings, 'total' | 'page'> | false;
+    rowClassFunction?: (rowData: T) => string;
+}
+interface SmartTableAction<T extends BaseDataType = any> {
+    columnTitle?: string;
+    add?: boolean;
+    edit?: boolean;
+    delete?: boolean;
+    custom?: SmartTableCustomAction<T>[];
+}
+interface SmartTableCustomAction<T extends BaseDataType = any> {
+    name: string;
+    title: string;
+    hasPermissionFunction?: (row: T) => boolean;
+}
+type SmartTableColumnSettingsTypes = 'text' | 'html' | 'custom';
+type SmartTableColumnSettings<T extends BaseDataType = any> = SmartTableTextHtmlColumn<T> | SmartTableCustomColumn<T>;
+type SmartTableCompareFunction = (direction: number, a: any, b: any) => number;
+type SmartTableValuePrepareFunction<T extends BaseDataType = any> = (columnData: any, rowData: T, cell: Cell) => any;
+type SmartTableFilterFunction = (columnData: any, search: string) => boolean;
+interface SmartTableDefaultColumn<T extends BaseDataType> {
+    key: keyof T;
+    title: string;
+    style?: Partial<CSSStyleDeclaration>;
+    width?: string;
+    class?: string;
+    editable?: boolean;
+    hide?: boolean;
+    moveDisabled?: boolean;
+    sort?: boolean;
+    addable?: boolean;
+    sortDirection?: SmartTableSortDirection | false;
+    editor?: SmartTableEditorAndFilter;
+    filter?: SmartTableEditorAndFilter | false;
+    compareFunction?: SmartTableCompareFunction;
+    valuePrepareFunction?: SmartTableValuePrepareFunction<T>;
+    filterFunction?: SmartTableFilterFunction;
+}
+interface SmartTableTextHtmlColumn<T extends BaseDataType> extends SmartTableDefaultColumn<T> {
+    type: 'text' | 'html';
+}
+interface SmartTableCustomColumn<T extends BaseDataType> extends SmartTableDefaultColumn<T> {
+    type: 'custom';
+    renderComponent: ComponentType<any>;
+    /**
+     * @description you can set any component inputs.
+     * inputs value is not updated when changed. set once onInit.
+     * make sure to set the correct input name to prevent setInput error
+     */
+    inputs?: Record<string, any>;
+}
+type SmartTableEditorAndFilterTypes = 'text' | 'textarea' | 'list' | 'custom' | 'checkbox';
+type SmartTableEditorAndFilter = SmartTableTextEditor | SmartTableEditorList | SmartTableEditorCheckbox | SmartTableEditorCustom;
+interface SmartTableTextEditor {
+    type: 'text' | 'textarea';
+    config?: {
+        placeholder?: string;
+    } & Record<string, any>;
+}
+interface SmartTableEditorList {
+    type: 'list';
+    config: {
+        placeholder?: string;
+        selectText?: string;
+        list: SelectOption[];
+    } & Record<string, any>;
+}
+interface SmartTableEditorCheckbox {
+    type: 'checkbox';
+    config?: {
+        true: any;
+        false: any;
+        resetText?: string;
+    } & Record<string, any>;
+}
+interface SmartTableEditorCustom {
+    type: 'custom';
+    component: ComponentType<any>;
+    config?: {
+        placeholder?: string;
+        /**
+         * @description you can set any component inputs.
+         * inputs value is not updated when changed. set once onInit.
+         * make sure to set the correct input name to prevent setInput error
+         */
+        inputs?: Record<string, any>;
+    } & Record<string, any>;
+}
+interface SmartTablePagerSettings {
+    display: boolean;
+    nextButtonText?: string;
+    previewButtonText?: string;
+    showTotal?: boolean;
+    page: number;
+    perPage: number;
+    perPageSelect?: number[];
+    total: number;
+}
+interface SmartTableFilterItem {
+    /**
+     * key of column to filter
+     */
+    type: SmartTableEditorAndFilterTypes;
+    field: string;
+    search: string;
+    filter?: SmartTableFilterFunction;
+}
+type SmartTableSortDirection = 'asc' | 'desc';
+interface SmartTableSortItem {
+    field: string;
+    title: string;
+    direction: SmartTableSortDirection;
+    compare?: SmartTableCompareFunction;
+}
+interface SmartTableDefaultEvent<T extends BaseDataType = any> {
+    confirm: Deferred<T>;
+    data: T;
+    source: DataSource<T>;
+}
+type SmartTableConfirmDeleteEvent<T extends BaseDataType = any> = SmartTableDefaultEvent<T>;
+type SmartTableRowClickedEvent<T extends BaseDataType = any> = Omit<SmartTableDefaultEvent<T>, 'confirm'>;
+interface SmartTableCustomEvent<T extends BaseDataType = any> extends Omit<SmartTableDefaultEvent<T>, 'confirm'> {
+    action: string;
+}
+interface SmartTableRowSelectEvent<T extends BaseDataType = any> extends Omit<SmartTableDefaultEvent<T>, 'confirm'> {
+    isSelected: boolean;
+    selected: T[];
+}
+interface SmartTableConfirmEditEvent<T extends BaseDataType = any, N = T> extends SmartTableDefaultEvent<T> {
+    newData: N;
+}
+interface SmartTableCreateConfirm<T extends BaseDataType = any> extends Omit<SmartTableDefaultEvent<T>, 'data'> {
+    newData: T;
+}
+declare enum SmartTableOnChangedEventName {
+    'load' = "load",
+    'paging' = "paging",
+    'update' = "update",
+    'page' = "page",
+    'filter' = "filter",
+    'empty' = "empty",
+    'sort' = "sort",
+    'add' = "add",
+    'remove' = "remove",
+    'appendMany' = "appendMany",
+    'prepend' = "prepend",
+    'refresh' = "refresh",
+    'columnRefresh' = "columnRefresh"
+}
+type SmartTableOnChangedEventType = `${SmartTableOnChangedEventName}`;
+interface SmartTableOnChangedEventBase<T extends BaseDataType = any> {
+    elements: T[];
+    filters: SmartTableFilterItem[];
+    paging: SmartTablePagerSettings;
+    sort: SmartTableSortItem | null;
+}
+interface SmartTableOnChangedEventAll {
+    action: Exclude<SmartTableOnChangedEventType, 'remove' | 'update' | 'append' | 'prepend' | 'appendMany' | 'add'>;
+}
+interface SmartTableAddEvent<T extends BaseDataType = any> {
+    action: SmartTableOnChangedEventName.add | SmartTableOnChangedEventName.prepend | SmartTableOnChangedEventName.appendMany;
+    newItems: T[];
+}
+interface SmartTableUpdateEvent<T extends BaseDataType = any> {
+    action: SmartTableOnChangedEventName.update;
+    newItem: T;
+    oldItem: T;
+}
+interface SmartTableRemoveEvent<T extends BaseDataType = any> {
+    action: SmartTableOnChangedEventName.remove;
+    item: T;
+}
+type SmartTableOnChangedEventToEmit<T extends BaseDataType = any> = SmartTableAddEvent<T> | SmartTableUpdateEvent<T> | SmartTableRemoveEvent<T> | SmartTableOnChangedEventAll;
+type SmartTableOnChangedEvent<T extends BaseDataType = any> = SmartTableOnChangedEventToEmit<T> & SmartTableOnChangedEventBase<T>;
+interface SmartTableConfirmEvent<T extends BaseDataType = any> {
+    confirm: {
+        resolve: (data?: T) => void;
+        reject: () => void;
+    };
+    data: T;
+    source: DataSource<T>;
+}
+interface SmartTableBaseEvent<T extends BaseDataType = any> {
+    data: T | null;
+    source: DataSource<T>;
+}
+type SmartTableCreateEvent<T extends BaseDataType = any> = SmartTableBaseEvent<T>;
+type SmartTableEditEvent<T extends BaseDataType = any> = SmartTableBaseEvent<T>;
+type SmartTableDeleteEvent<T extends BaseDataType = any> = SmartTableConfirmEvent<T>;
+type SmartTableEditCancelEvent<T extends BaseDataType = any> = SmartTableBaseEvent<T>;
+
+declare class Row {
+    index: number;
+    protected rowDataObj: any;
+    protected columnsList: Column[];
+    readonly pending: _angular_core.WritableSignal<boolean>;
+    readonly isSelected: _angular_core.WritableSignal<boolean>;
+    readonly isInEditing: _angular_core.WritableSignal<boolean>;
+    readonly cells: _angular_core.Signal<Cell[]>;
+    readonly rowData: _angular_core.WritableSignal<any>;
+    readonly columns: _angular_core.WritableSignal<Column[]>;
+    readonly visibleCells: _angular_core.Signal<Cell[]>;
+    constructor(index: number, rowDataObj: any, columnsList: Column[]);
+    getNewData(): any;
+    setData<T = any>(rowData: T): void;
+    createCell(column: Column, rowData: any): Cell;
+}
+
+declare class DataSet {
+    protected columnSettings: SmartTableColumnSettings[];
+    readonly editorInputClass: string;
+    newRow: Row;
+    protected readonly data: _angular_core.WritableSignal<any[]>;
+    protected readonly columns: _angular_core.WritableSignal<Column[]>;
+    protected readonly rows: _angular_core.WritableSignal<Row[]>;
+    protected selectedRowsData: any[];
+    readonly getColumns: _angular_core.Signal<Column[]>;
+    readonly getVisibleColumns: _angular_core.Signal<Column[]>;
+    readonly getRows: _angular_core.Signal<Row[]>;
+    readonly isAllSelected: _angular_core.Signal<boolean>;
+    constructor(dataList: any[] | undefined, columnSettings: SmartTableColumnSettings[], editorInputClass: string);
+    setData(data: any[]): void;
+    setColumnsConfig(columnSettings: SmartTableColumnSettings[]): void;
+    findRowByData(data: any): Row | undefined;
+    setSelectAll(state: boolean): void;
+    resetAllSelection(): void;
+    selectRow(row: Row, state: boolean): void;
+    multipleSelectRow(row: Row): Row;
+    getSelectedRowsData(): any[];
+    createNewRow(): void;
+    /**
+     * Create columns by mapping from the settings
+     * @param settings
+     * @private
+     */
+    createColumns(columnsParams: SmartTableColumnSettings[]): void;
+    /**
+     * Create rows based on current data prepared in data source
+     * @private
+     */
+    createRows(): void;
+    private isSelectedHasRow;
+    private storeSelectedRow;
+}
+
+declare class Column {
+    id: string;
+    private settings;
+    protected dataSet: DataSet;
+    readonly title: string;
+    readonly type: SmartTableColumnSettingsTypes;
+    readonly class: string;
+    readonly styles: Partial<CSSStyleDeclaration>;
+    readonly editorInputClass: string;
+    hide: boolean;
+    isSortable: boolean;
+    isEditable: boolean;
+    isAddable: boolean;
+    isFilterable: boolean;
+    editor: SmartTableEditorAndFilter | false;
+    filter: SmartTableEditorAndFilter | false;
+    renderComponent?: ComponentType<any>;
+    renderComponentInputs: Record<string, any>;
+    compareFunction?: SmartTableCompareFunction;
+    valuePrepareFunction?: SmartTableValuePrepareFunction;
+    filterFunction?: SmartTableFilterFunction;
+    constructor(id: string, settings: SmartTableColumnSettings, dataSet: DataSet);
+    getEditorConfig(): SmartTableEditorAndFilter['config'] | undefined;
+    getFilterType(): false | "text" | "custom" | "textarea" | "list" | "checkbox";
+    getFilterConfig(): SmartTableEditorAndFilter['config'] | undefined;
+}
+
+declare class Cell {
+    protected value: any;
+    row: Row;
+    column: Column;
+    readonly newValue: _angular_core.WritableSignal<any>;
+    readonly columnClass: string;
+    readonly styles: Partial<CSSStyleDeclaration>;
+    readonly title: string;
+    readonly id: string;
+    constructor(value: any, row: Row, column: Column);
+    getValue(): any;
+    getNotPrepareValue(): any;
+    setNewValue(value: any): void;
+    isEditable(): boolean;
+}
+
+declare class BaseEditorComponent implements Editor {
+    readonly cell: InputSignal<Cell>;
+    readonly inputClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseEditorComponent, "ng2-editor-base-component", never, { "cell": { "alias": "cell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface Editor {
+    cell: InputSignal<Cell>;
+}
+
+declare class BaseFilterComponent implements FilterComponent, OnDestroy, OnInit {
+    delay: number;
+    changesSubscription?: Subscription;
+    readonly query: InputSignal<unknown>;
+    readonly inputClass: InputSignal<string>;
+    readonly source: InputSignal<DataSource<any>>;
+    readonly column: InputSignal<Column>;
+    readonly filterEmitter: InputSignal<OutputEmitterRef<any>>;
+    readonly inputControl: UntypedFormControl;
+    placeholder: string;
+    constructor();
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    setFilter(query: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFilterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseFilterComponent, "ng2-base-filter-component", never, { "query": { "alias": "query"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "column": { "alias": "column"; "required": true; "isSignal": true; }; "filterEmitter": { "alias": "filterEmitter"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface FilterComponent {
+    delay?: number;
+    changesSubscription?: Subscription;
+    readonly query: InputSignal<unknown>;
+    readonly inputClass: InputSignal<string>;
+    readonly source: InputSignal<DataSource>;
+    readonly column: InputSignal<Column>;
+    readonly filterEmitter: InputSignal<OutputEmitterRef<any>>;
+}
+
+declare class Grid {
+    source: DataSource;
+    dataSet: DataSet;
+    currentColumnsSortState: ColumnPositionState[];
+    private columnsSortedEmitter;
+    private sourceOnChangedSubscription;
+    readonly settings: _angular_core.WritableSignal<SmartTableSettings<any>>;
+    readonly createFormShown: _angular_core.WritableSignal<boolean>;
+    readonly isMultiSelectVisible: _angular_core.Signal<boolean>;
+    readonly isActionsVisible: _angular_core.Signal<boolean>;
+    readonly actionIsOnLeft: _angular_core.Signal<boolean>;
+    readonly actionIsOnRight: _angular_core.Signal<boolean>;
+    readonly columnSortDragDelay: _angular_core.Signal<number>;
+    private readonly columnStateStorageKey;
+    constructor(source: DataSource | undefined, settings: SmartTableSettings);
+    setColumnsSortedEmitter(emitter: OutputEmitterRef<ColumnPositionState[]>): void;
+    detach(): void;
+    getNewRow(): Row;
+    setSettings(settings: SmartTableSettings): void;
+    getDataSet(): DataSet;
+    getSetting<T>(name: string, defaultValue?: any): T;
+    selectRow(row: Row, state: boolean): void;
+    multipleSelectRow(row: Row): void;
+    edit(row: Row): void;
+    create(row: Row, confirmEmitter: EventEmitter<any> | OutputEmitterRef<any>): void;
+    save(row: Row, confirmEmitter: EventEmitter<any> | OutputEmitterRef<any>): void;
+    delete<T extends BaseDataType = BaseDataType>(row: Row, confirmEmitter: EventEmitter<SmartTableConfirmDeleteEvent<T>> | OutputEmitterRef<SmartTableConfirmDeleteEvent<T>>): void;
+    private processDataChange;
+    private prepareSource;
+    private getInitialSort;
+    getSelectedRowsData(): any[];
+    selectAllRows(status: boolean): void;
+    private updateSettingsAndDataSet;
+    private setSource;
+    private getSortedTableColumns;
+    applyColumnsSortState(state: ColumnPositionState[], emitEvent?: boolean): Promise<void>;
+    private setColumnsSortState;
+    private getColumnsStateFromSettings;
+    private getMergedColumnStates;
+}
+
+declare class Ng2SmartTableComponent<T extends BaseDataType = any> implements OnChanges, OnDestroy, AfterViewInit {
+    private readonly elementRef;
+    private readonly ngZone;
+    private readonly injector;
+    readonly source: _angular_core.InputSignal<DataSource<T>>;
+    readonly settings: _angular_core.InputSignal<SmartTableSettings<T>>;
+    /**
+     * @description If you want to display pagination in your custom container, you can pass it to "paginationSlot".
+     * @example
+     * <ng2-smart-table
+     *    [paginationSlot]="paginationContainerRef()">
+     * </ng2-smart-table>
+     * <div #paginationSlot>
+     * </div>
+     * inside component
+     * readonly paginationContainerRef = viewChild('paginationSlot', {
+     *  read: ViewContainerRef,
+     * });
+     */
+    readonly paginationSlot: _angular_core.InputSignal<ViewContainerRef | undefined>;
+    /**
+     * @description if you want to render custom data inside a container with pagination you can pass a TemplateRef
+     * @example
+     * <ng2-smart-table
+     *    [paginationTemplateData]="paginationData"
+     * >
+     * </ng2-smart-table>
+     * <ng-template #paginationData
+     * >
+     *    any data
+     * </ng-template>
+     * ----- or another option, will work only if you do not use paginationSlot
+     * <ng2-smart-table
+     *    [paginationTemplateData]="paginationData"
+     * >
+     *    <ng-container pager-content>
+     *        some content will be rendered in the pager
+     *    </ng-container>
+     * </ng2-smart-table>
+     */
+    readonly paginationTemplateData: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    readonly multiRowSelect: _angular_core.OutputEmitterRef<SmartTableRowSelectEvent<T>>;
+    readonly rowClicked: _angular_core.OutputEmitterRef<SmartTableRowClickedEvent<T>>;
+    readonly columnsSorted: _angular_core.OutputEmitterRef<ColumnPositionState[]>;
+    readonly deleteEmitter: _angular_core.OutputEmitterRef<SmartTableBaseEvent<T>>;
+    readonly deleteConfirm: _angular_core.OutputEmitterRef<SmartTableConfirmDeleteEvent<T>>;
+    readonly edit: _angular_core.OutputEmitterRef<SmartTableBaseEvent<T>>;
+    readonly editConfirm: _angular_core.OutputEmitterRef<SmartTableConfirmEditEvent<T, T>>;
+    readonly editCancel: _angular_core.OutputEmitterRef<SmartTableBaseEvent<T>>;
+    readonly create: _angular_core.OutputEmitterRef<SmartTableBaseEvent<T>>;
+    readonly createConfirm: _angular_core.OutputEmitterRef<SmartTableCreateConfirm<T>>;
+    readonly custom: _angular_core.OutputEmitterRef<SmartTableCustomEvent<T>>;
+    protected readonly tableClass: _angular_core.Signal<string>;
+    protected readonly tableId: _angular_core.Signal<string>;
+    protected readonly isPagerDisplay: _angular_core.Signal<boolean>;
+    protected readonly rowClassFunction: _angular_core.Signal<(rowData: T) => string>;
+    protected readonly isMobileView: _angular_core.WritableSignal<boolean>;
+    protected readonly tableWidthMobileBreakpoint: _angular_core.Signal<number | undefined>;
+    grid: Grid;
+    private readonly isExternalMode;
+    private resizeObserver;
+    private resizeDebounceTimer;
+    private paginationComponentRef;
+    ngOnChanges({ settings }: Record<string, SimpleChange>): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected multipleSelectRow(row: Row): void;
+    protected onSelectAllRows(): void;
+    protected onSelectRow(row: Row, state: boolean): void;
+    protected emitUserRowClicked(row: Row): void;
+    protected customActionEmitted(event: SmartTableCustomEvent<T>): void;
+    protected editEmitted(row: Row): void;
+    protected editConfirmed(row: Row): void;
+    protected editCanceled(row: Row): void;
+    protected createEmitted(): void;
+    protected createConfirmed(): void;
+    protected deleEmitted(row: Row): void;
+    private initGrid;
+    private emitUserSelectRow;
+    private setupResizeObserver;
+    private destroyResizeObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Ng2SmartTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Ng2SmartTableComponent<any>, "ng2-smart-table", never, { "source": { "alias": "source"; "required": true; "isSignal": true; }; "settings": { "alias": "settings"; "required": true; "isSignal": true; }; "paginationSlot": { "alias": "paginationSlot"; "required": false; "isSignal": true; }; "paginationTemplateData": { "alias": "paginationTemplateData"; "required": false; "isSignal": true; }; }, { "multiRowSelect": "multiRowSelect"; "rowClicked": "rowClicked"; "columnsSorted": "columnsSorted"; "deleteEmitter": "deleteEmitter"; "deleteConfirm": "deleteConfirm"; "edit": "edit"; "editConfirm": "editConfirm"; "editCancel": "editCancel"; "create": "create"; "createConfirm": "createConfirm"; "custom": "custom"; }, never, ["[pager-content]"], true, never>;
+}
+
+declare class SmartTableColumnEditorDirective implements OnDestroy {
+    readonly tableComponent: _angular_core.InputSignal<Ng2SmartTableComponent<any> | undefined>;
+    private readonly grid;
+    private readonly overlay;
+    private readonly elementRef;
+    private readonly destroy$;
+    protected overlayRef?: OverlayRef;
+    ngOnDestroy(): void;
+    protected showDropdown(): void;
+    hide(): void;
+    buttonClicked(): void;
+    private getOverlayConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartTableColumnEditorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SmartTableColumnEditorDirective, "[ng2SmartTableColumnEditor]", never, { "tableComponent": { "alias": "tableComponent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LocalDataSource<T extends Record<string, any> = any> extends DataSource<T> {
+    private readonly filteredAndSorted;
+    readonly paginatedList: _angular_core.Signal<T[]>;
+    readonly count: _angular_core.Signal<number>;
+    constructor(data?: T[]);
+    load(data: T[]): Promise<true>;
+    prepend(element: T): Promise<true>;
+    appendMany(elements: T[]): Promise<true>;
+    add(element: T): Promise<true>;
+    getAll(): Promise<T[]>;
+    reset(silent?: boolean): void;
+    emitOnChanged(event: SmartTableOnChangedEventToEmit, newElements?: T[]): Promise<void>;
+    protected paginate(data: T[]): T[];
+    private isPageOutOfBounce;
+}
+
+type ParamsPrepareFunction = (options: {
+    sort: SmartTableSortItem | null;
+    filters: SmartTableFilterItem[];
+    page: number;
+    limit: number;
+}) => Observable<HttpParams>;
+type RequestFunction<T extends Record<string, any> = any> = (params: HttpParams) => Observable<{
+    total: number;
+    data: T[];
+}>;
+declare class ServerDataSource<T extends Record<string, any> = any> extends DataSource<T> {
+    private initPagingConf?;
+    paramPrepareFunction: ParamsPrepareFunction;
+    requestFunction: RequestFunction<T>;
+    readonly count: _angular_core.Signal<number>;
+    readonly pending: _angular_core.WritableSignal<boolean>;
+    constructor(paramPrepareFunction: ParamsPrepareFunction, requestFunction: RequestFunction<T>, initPagingConf?: Partial<SmartTablePagerSettings> | undefined);
+    getAll(): Promise<T[]>;
+    emitOnChanged(eventData: SmartTableOnChangedEventToEmit, newElements?: T[] | undefined): void;
+}
+
+export { BaseEditorComponent, BaseFilterComponent, Cell, Column, DataSource, Deferred, LocalDataSource, Ng2SmartTableComponent, Row, ServerDataSource, SmartTableColumnEditorDirective, SmartTableOnChangedEventName };
+export type { ActionPosition, BaseDataType, ColumnPositionState, Editor, FilterComponent, ParamsPrepareFunction, RequestFunction, SmartTableAction, SmartTableBaseEvent, SmartTableColumnSettings, SmartTableColumnSettingsTypes, SmartTableCompareFunction, SmartTableConfirmDeleteEvent, SmartTableConfirmEditEvent, SmartTableConfirmEvent, SmartTableCreateConfirm, SmartTableCreateEvent, SmartTableCustomAction, SmartTableCustomEvent, SmartTableDeleteEvent, SmartTableEditCancelEvent, SmartTableEditEvent, SmartTableEditorAndFilter, SmartTableEditorAndFilterTypes, SmartTableEditorCustom, SmartTableFilterFunction, SmartTableFilterItem, SmartTableOnChangedEvent, SmartTableOnChangedEventToEmit, SmartTableOnChangedEventType, SmartTablePagerSettings, SmartTableRowClickedEvent, SmartTableRowSelectEvent, SmartTableSettings, SmartTableSortDirection, SmartTableSortItem, SmartTableValuePrepareFunction, ViewCell };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@den4ik92/ng2-smart-table",
-  "version": "19.6.47",
+  "version": "20.0.0",
   "description": "Angular Smart Table",
   "author": "Den4ik92",
   "license": "MIT",
@@ -8,10 +8,10 @@
     "tslib": "^2.6.1"
   },
   "peerDependencies": {
-    "@angular/common": "^19.2.14",
-    "@angular/core": "^19.2.14",
-    "@angular/forms": "^19.2.14",
-    "@angular/cdk": "^19.2.14"
+    "@angular/common": "^20.3.4",
+    "@angular/core": "^20.3.4",
+    "@angular/forms": "^20.3.4",
+    "@angular/cdk": "^20.2.8"
   },
   "module": "fesm2022/den4ik92-ng2-smart-table.mjs",
   "typings": "index.d.ts",

package/lib/components/cell/cell-edit-mode/build-in-editor.component.d.ts

@@ -1,8 +0,0 @@
-import { SmartTableEditorAndFilterTypes } from '../../../lib/interfaces/smart-table.models';
-import { BaseEditorComponent } from '../cell-editors/base-editor.component';
-import * as i0 from "@angular/core";
-export declare class BuildInEditorComponent extends BaseEditorComponent {
-    protected readonly editorType: import("@angular/core").Signal<SmartTableEditorAndFilterTypes>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BuildInEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BuildInEditorComponent, "ng2-table-cell-build-in-editor", never, {}, {}, never, never, true, never>;
-}

package/lib/components/cell/cell-edit-mode/custom-edit.component.d.ts

@@ -1,11 +0,0 @@
-import { OnChanges, OnDestroy, SimpleChanges, ViewContainerRef } from '@angular/core';
-import { BaseEditorComponent } from '../cell-editors/base-editor.component';
-import * as i0 from "@angular/core";
-export declare class CustomEditComponent extends BaseEditorComponent implements OnChanges, OnDestroy {
-    dynamicTarget?: ViewContainerRef;
-    private customComponent?;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CustomEditComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CustomEditComponent, "ng2-table-cell-custom-editor", never, {}, {}, never, never, true, never>;
-}