@den4ik92/ng2-smart-table 19.1.6 → 19.2.1

package/lib/lib/data-set/column.d.ts

@@ -5,17 +5,16 @@ export declare class Column {
     id: string;
     private settings;
     protected dataSet: DataSet;
-    title: string;
-    type: SmartTableColumnSettingsTypes;
-    class: string;
-    width: string;
+    readonly title: string;
+    readonly type: SmartTableColumnSettingsTypes;
+    readonly class: string;
+    readonly width: string;
     hide: boolean;
     isSortable: boolean;
     isEditable: boolean;
     isAddable: boolean;
     isFilterable: boolean;
     sortDirection: SmartTableSortDirection;
-    defaultSortDirection: SmartTableSortDirection | false;
     editor: SmartTableEditorAndFilter | false;
     filter: SmartTableEditorAndFilter | false;
     renderComponent: any;
@@ -23,12 +22,7 @@ export declare class Column {
     valuePrepareFunction?: SmartTableValuePrepareFunction;
     filterFunction?: SmartTableFilterFunction;
     constructor(id: string, settings: SmartTableColumnSettings, dataSet: DataSet);
-    getCompareFunction(): SmartTableCompareFunction | undefined;
-    getValuePrepareFunction(): SmartTableValuePrepareFunction | undefined;
-    getFilterFunction(): SmartTableFilterFunction | undefined;
-    getConfig(): any;
+    getEditorConfig(): SmartTableEditorAndFilter['config'] | false;
     getFilterType(): false | "text" | "custom" | "textarea" | "list" | "checkbox";
-    getFilterConfig(): any;
-    protected process(settings: SmartTableColumnSettings): void;
-    prepareSortDirection(): SmartTableSortDirection;
+    getFilterConfig(): SmartTableEditorAndFilter['config'] | false;
 }

package/lib/lib/data-set/data-set.d.ts

@@ -4,14 +4,16 @@ import { Row } from "./row";
 export declare class DataSet {
     protected columnSettings: SmartTableColumnSettings[];
     newRow: Row;
-    protected data: any[];
-    protected columns: Column[];
-    protected rows: Row[];
-    protected selectedRows: Set<Row>;
+    protected readonly data: import("@angular/core").WritableSignal<any[]>;
+    protected readonly columns: import("@angular/core").WritableSignal<Column[]>;
+    protected readonly rows: import("@angular/core").WritableSignal<Row[]>;
+    protected readonly selectedRows: Set<Row>;
+    readonly getColumns: import("@angular/core").Signal<Column[]>;
+    readonly getVisibleColumns: import("@angular/core").Signal<Column[]>;
+    readonly getRows: import("@angular/core").Signal<Row[]>;
+    readonly isAllSelected: import("@angular/core").Signal<boolean>;
     constructor(data: any[] | undefined, columnSettings: SmartTableColumnSettings[]);
     setData(data: any[]): void;
-    getColumns(): Column[];
-    getRows(): Row[];
     getFirstRow(): Row;
     getLastRow(): Row;
     findRowByData(data: any): Row | undefined;
@@ -32,6 +34,5 @@ export declare class DataSet {
      * @private
      */
     createRows(): void;
-    get isAllSelected(): boolean;
     private storeSelectedRow;
 }

package/lib/lib/data-set/row.d.ts

@@ -1,6 +1,6 @@
-import { Cell } from './cell';
-import { Column } from './column';
-import { DataSet } from './data-set';
+import { Cell } from "./cell";
+import { Column } from "./column";
+import { DataSet } from "./data-set";
 export declare class Row {
     index: number;
     private data;
@@ -8,10 +8,10 @@ export declare class Row {
     readonly pending: import("@angular/core").WritableSignal<boolean>;
     readonly isSelected: import("@angular/core").WritableSignal<boolean>;
     readonly isInEditing: import("@angular/core").WritableSignal<boolean>;
-    cells: Cell[];
+    readonly cells: import("@angular/core").WritableSignal<Cell[]>;
+    readonly visibleCells: import("@angular/core").Signal<Cell[]>;
     constructor(index: number, data: any, _dataSet: DataSet);
     getCell(column: Column): Cell | undefined;
-    getCells(): Cell[];
     getData(): any;
     getNewData(): any;
     setData<T = any>(data: T): void;

package/lib/lib/data-source/data-source.d.ts

@@ -1,35 +1,32 @@
 import { Observable, Subject } from 'rxjs';
-import { SmartTableFilterConf, SmartTableOnChangedEvent, SmartTableOnChangedEventType, SmartTablePagingItem, SmartTableSortItem } from '../interfaces/smart-table.models';
+import { SmartTableFilterItem, SmartTableOnChangedEvent, SmartTableOnChangedEventToEmit, SmartTablePagerSettings, SmartTableSortItem } from '../interfaces/smart-table.models';
 export declare abstract class DataSource<T = any> {
-    protected onChangedSource: Subject<SmartTableOnChangedEvent<any>>;
-    protected onAddedSource: Subject<any>;
-    protected onUpdatedSource: Subject<any>;
-    protected onRemovedSource: Subject<any>;
+    protected onChangedSource: Subject<SmartTableOnChangedEvent>;
+    protected sortConf: SmartTableSortItem;
+    protected filters: SmartTableFilterItem[];
+    readonly pagingConf: import("@angular/core").WritableSignal<SmartTablePagerSettings>;
+    protected data: T[];
+    /**
+     * return all elements
+     */
     abstract getAll(): Promise<T[]>;
-    abstract getElements(): Promise<T[]>;
-    abstract getSort(): SmartTableSortItem[];
-    abstract getFilter(): SmartTableFilterConf;
-    abstract getPaging(): SmartTablePagingItem | false;
+    abstract getSort(): SmartTableSortItem;
+    abstract getFilters(): SmartTableFilterItem[];
     abstract count(): number;
     refresh(): void;
-    loadEmit(): Promise<true>;
+    columnRefresh(): void;
     onChanged(): Observable<SmartTableOnChangedEvent>;
-    onAdded(): Observable<any>;
-    onUpdated(): Observable<any>;
-    onRemoved(): Observable<any>;
-    prependEmit(element: T): Promise<true>;
-    appendEmit(element: T): Promise<true>;
-    addEmit(element: T): Promise<true>;
-    removeEmit(element: T): Promise<true>;
-    updateEmit(element: T): Promise<true>;
-    emptyEmit(): Promise<true>;
-    setSortEmit(): void;
-    setFilterEmit(): void;
-    addFilterEmit(): void;
-    setPagingEmit(): void;
-    setPageEmit(): void;
-    protected emitOnRemoved(element: T): void;
-    protected emitOnUpdated(element: T): void;
-    protected emitOnAdded(element: T): void;
-    protected emitOnChanged(action: SmartTableOnChangedEventType): void;
+    prepend(element: T): Promise<true>;
+    appendMany(elements: T[]): Promise<true>;
+    append(element: 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, doEmit?: boolean): void;
+    addFilter(newFilter: SmartTableFilterItem, doEmit?: boolean): 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;
 }

package/lib/lib/data-source/local/local.data-source.d.ts

@@ -1,57 +1,20 @@
-import { SmartTableFilterConf, SmartTableFilterItem, SmartTablePagingItem, SmartTableSortItem } from '../../interfaces/smart-table.models';
+import { SmartTableFilterItem, SmartTableOnChangedEventToEmit, SmartTableSortItem } from '../../interfaces/smart-table.models';
 import { DataSource } from '../data-source';
 export declare class LocalDataSource<T extends Record<string, any> = any> extends DataSource<T> {
-    protected data: T[];
-    protected filteredAndSorted: T[];
-    protected sortConf: SmartTableSortItem[];
-    protected filterConf: SmartTableFilterConf;
-    protected pagingConf: SmartTablePagingItem | false;
+    private readonly filteredAndSorted;
     constructor(data?: T[]);
-    load(data: any): Promise<true>;
+    load(data: T[]): Promise<true>;
     prepend(element: T): Promise<true>;
     appendMany(elements: T[]): Promise<true>;
     append(element: T): Promise<true>;
-    add(element: T): Promise<true>;
-    remove(element: T): Promise<true>;
-    update(element: T, values: T): Promise<true>;
-    find(element: T): Promise<T>;
-    getElements(): Promise<T[]>;
-    getFilteredAndSorted(): Promise<T[]>;
     getAll(): Promise<T[]>;
     reset(silent?: boolean): void;
-    empty(): Promise<true>;
-    count(): number;
-    /**
-     *
-     * Array of conf objects
-     * [
-     *  {field: string, direction: asc|desc|null, compare: Function|null},
-     * ]
-     * @param conf
-     * @param doEmit
-     * @returns {LocalDataSource}
-     */
-    setSort(conf: SmartTableSortItem[], doEmit?: boolean): LocalDataSource;
-    /**
-     *
-     * Array of conf objects
-     * [
-     *  {field: string, search: string, filter: Function|null},
-     * ]
-     * @param conf
-     * @param andOperator
-     * @param doEmit
-     * @returns {LocalDataSource}
-     */
-    setFilter(conf: SmartTableFilterItem[], andOperator?: boolean, doEmit?: boolean): LocalDataSource;
-    addFilter(fieldConf: SmartTableFilterItem, andOperator?: boolean, doEmit?: boolean): LocalDataSource;
-    setPaging(page: number | undefined, perPage: number, doEmit?: boolean): void;
-    setPage(page: number, doEmit?: boolean): void;
-    getSort(): SmartTableSortItem[];
-    getFilter(): SmartTableFilterConf;
-    getPaging(): SmartTablePagingItem | false;
-    protected prepareData(data: T[]): T[];
+    readonly count: import("@angular/core").Signal<number>;
+    getSort(): SmartTableSortItem;
+    getFilters(): SmartTableFilterItem[];
+    emitOnChanged(event: SmartTableOnChangedEventToEmit): void;
     protected sort(data: T[]): T[];
     protected filter(data: T[]): T[];
     protected paginate(data: T[]): T[];
+    private isPageOutOfBounce;
 }

package/lib/lib/data-source/local/local.filter.d.ts

@@ -1,4 +1,2 @@
-export declare function filterValues(value: string, search: string): boolean;
-export declare class LocalFilter {
-    static filter(data: any[], field: string, search: string, customFilter?: Function): any[];
-}
+import { SmartTableFilterItem } from "../../interfaces/smart-table.models";
+export declare function isElementSatisfied<T extends Record<string, unknown>>(element: T, filters: SmartTableFilterItem[]): boolean;

package/lib/lib/data-source/local/local.pager.d.ts

@@ -1,3 +1 @@
-export declare class LocalPager {
-    static paginate(data: Array<any>, page: number, perPage: number): Array<any>;
-}
+export declare function paginateList(data: any[], page: number, perPage: number): any[];

package/lib/lib/data-source/server/server.data-source.d.ts

@@ -0,0 +1,25 @@
+import { HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { SmartTableFilterItem, SmartTableOnChangedEventToEmit, SmartTablePagerSettings, SmartTableSortItem } from '../../interfaces/smart-table.models';
+import { DataSource } from '../data-source';
+export type ParamsPrepareFunction = (options: {
+    sort: SmartTableSortItem;
+    filters: SmartTableFilterItem[];
+    page: number;
+    limit: number;
+}) => Observable<HttpParams>;
+export type RequestFunction<T extends Record<string, any> = any> = (params: HttpParams) => Observable<{
+    total: number;
+    data: T[];
+}>;
+export declare class ServerDataSource<T extends Record<string, any> = any> extends DataSource<T> {
+    private initPagingConf?;
+    readonly count: import("@angular/core").Signal<number>;
+    paramPrepareFunction: ParamsPrepareFunction;
+    requestFunction: RequestFunction<T>;
+    constructor(paramPrepareFunction: ParamsPrepareFunction, requestFunction: RequestFunction<T>, initPagingConf?: Partial<SmartTablePagerSettings> | undefined);
+    getAll(): Promise<T[]>;
+    getSort(): SmartTableSortItem;
+    getFilters(): SmartTableFilterItem[];
+    emitOnChanged(eventData: SmartTableOnChangedEventToEmit, newElements?: T[] | undefined): void;
+}

package/lib/lib/grid.d.ts

@@ -1,16 +1,12 @@
-import { EventEmitter, OutputEmitterRef } from "@angular/core";
-import { Observable, Subject } from "rxjs";
-import { LocalDataSource } from "./data-source/local/local.data-source";
-import { Column } from "./data-set/column";
-import { DataSet } from "./data-set/data-set";
-import { Row } from "./data-set/row";
-import { ColumnPositionState, SmartTableSettings } from "./interfaces/smart-table.models";
+import { EventEmitter, OutputEmitterRef } from '@angular/core';
+import { DataSet } from './data-set/data-set';
+import { Row } from './data-set/row';
+import { DataSource } from './data-source/data-source';
+import { ColumnPositionState, SmartTableSettings } from './interfaces/smart-table.models';
 export declare class Grid {
     createFormShown: boolean;
-    source: LocalDataSource;
+    source: DataSource;
     dataSet: DataSet;
-    onSelectRowSource: Subject<any>;
-    onDeselectRowSource: Subject<any>;
     currentColumnsSortState: ColumnPositionState[];
     private columnsSortedEmitter;
     private sourceOnChangedSubscription;
@@ -20,19 +16,15 @@ export declare class Grid {
     readonly isActionsVisible: import("@angular/core").Signal<boolean>;
     readonly actionIsOnLeft: import("@angular/core").Signal<boolean>;
     readonly actionIsOnRight: import("@angular/core").Signal<boolean>;
-    constructor(source: LocalDataSource | undefined, settings: SmartTableSettings);
+    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;
-    getColumns(): Column[];
-    getRows(): Row[];
     selectRow(row: Row, state: boolean): void;
     multipleSelectRow(row: Row): void;
-    onSelectRow(): Observable<any>;
-    onDeselectRow(): Observable<any>;
     edit(row: Row): void;
     create(row: Row, confirmEmitter: EventEmitter<any> | OutputEmitterRef<any>): void;
     save(row: Row, confirmEmitter: EventEmitter<any> | OutputEmitterRef<any>): void;

package/lib/lib/interfaces/smart-table.models.d.ts

@@ -1,6 +1,6 @@
-import { Cell } from "../data-set/cell";
-import { LocalDataSource } from "../data-source/local/local.data-source";
-import { Deferred } from "../helpers";
+import { Cell } from '../data-set/cell';
+import { DataSource } from '../data-source/data-source';
+import { Deferred } from '../helpers';
 interface SelectOption {
     title: string;
     value: any;
@@ -18,7 +18,7 @@ export interface ColumnPositionState {
 }
 export interface SmartTableSettings<T extends Record<string, any> = any> {
     selectMode?: 'single' | 'multi';
-    mode?: "inline" | "external";
+    mode?: 'inline' | 'external';
     columnSortStorageKey?: string;
     columnSort?: boolean;
     hideHeader?: boolean;
@@ -52,7 +52,7 @@ export interface SmartTableSettings<T extends Record<string, any> = any> {
     };
     noDataMessage?: string;
     columns: SmartTableColumnSettings<T>[];
-    pager?: SmartTablePagerSettings | false;
+    pager?: (Omit<SmartTablePagerSettings, 'total' | 'page'>) | false;
     rowClassFunction?: (row: {
         data: T;
     }) => string;
@@ -123,20 +123,20 @@ interface SmartTableEditorCustom {
     component: any;
     config?: any;
 }
-interface SmartTablePagerSettings {
+export interface SmartTablePagerSettings {
     display: boolean;
-    page?: number;
+    page: number;
     perPage: number;
     perPageSelect?: number[];
+    total: number;
 }
 export interface SmartTableFilterItem {
+    /**
+     * key of column to filter
+     */
     field: string;
     search: string;
-    filter?: any;
-}
-export interface SmartTablePagingItem {
-    page: number;
-    perPage: number;
+    filter?: SmartTableFilterFunction;
 }
 export type SmartTableSortDirection = 'asc' | 'desc';
 export interface SmartTableSortItem {
@@ -147,21 +147,21 @@ export interface SmartTableSortItem {
 interface SmartTableDefaultEvent<T> {
     confirm: Deferred<T>;
     data: T;
-    source: LocalDataSource;
+    source: DataSource<T>;
 }
 export type SmartTableConfirmDeleteEvent<T = any> = SmartTableDefaultEvent<T>;
-export type SmartTableRowClickedEvent<T = any> = Omit<SmartTableDefaultEvent<T>, "confirm">;
-export interface SmartTableCustomEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, "confirm"> {
+export type SmartTableRowClickedEvent<T = any> = Omit<SmartTableDefaultEvent<T>, 'confirm'>;
+export interface SmartTableCustomEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, 'confirm'> {
     action: string;
 }
-export interface SmartTableRowSelectEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, "confirm"> {
+export interface SmartTableRowSelectEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, 'confirm'> {
     isSelected: boolean;
     selected: T[];
 }
 export interface SmartTableConfirmEditEvent<T = any, N = T> extends SmartTableDefaultEvent<T> {
     newData: N;
 }
-export interface SmartTableCreateConfirm<T = any> extends Omit<SmartTableDefaultEvent<T>, "data"> {
+export interface SmartTableCreateConfirm<T = any> extends Omit<SmartTableDefaultEvent<T>, 'data'> {
     newData: T;
 }
 export type ObjectStringString = Record<string, string>;
@@ -176,19 +176,34 @@ export declare enum SmartTableOnChangedEventName {
     'add' = "add",
     'remove' = "remove",
     'append' = "append",
+    'appendMany' = "appendMany",
     'prepend' = "prepend",
-    'refresh' = "refresh"
+    'refresh' = "refresh",
+    'columnRefresh' = "columnRefresh"
 }
 export type SmartTableOnChangedEventType = `${SmartTableOnChangedEventName}`;
-export interface SmartTableOnChangedEvent<T extends Record<string, any> = any> {
-    action: SmartTableOnChangedEventType;
+interface SmartTableOnChangedEventBase<T extends Record<string, any> = any> {
     elements: T[];
-    filter: SmartTableFilterConf;
-    paging: SmartTablePagingItem | false;
-    sort: SmartTableSortItem[];
-}
-export interface SmartTableFilterConf {
     filters: SmartTableFilterItem[];
-    andOperator: boolean;
+    paging: SmartTablePagerSettings;
+    sort: SmartTableSortItem;
+}
+interface SmartTableOnChangedEventAll<T extends Record<string, any> = any> {
+    action: Exclude<SmartTableOnChangedEventType, 'remove' | 'update' | 'append' | 'prepend' | 'appendMany' | 'add'>;
+}
+interface SmartTableAddEvent<T extends Record<string, any> = any> {
+    action: SmartTableOnChangedEventName.add | SmartTableOnChangedEventName.prepend | SmartTableOnChangedEventName.append | SmartTableOnChangedEventName.appendMany;
+    newItems: T[];
+}
+interface SmartTableUpdateEvent<T extends Record<string, any> = any> {
+    action: SmartTableOnChangedEventName.update;
+    newItem: T;
+    oldItem: T;
+}
+interface SmartTableRemoveEvent<T extends Record<string, any> = any> {
+    action: SmartTableOnChangedEventName.remove;
+    item: T;
 }
+export type SmartTableOnChangedEventToEmit<T extends Record<string, any> = any> = SmartTableAddEvent<T> | SmartTableUpdateEvent<T> | SmartTableRemoveEvent<T> | SmartTableOnChangedEventAll<T>;
+export type SmartTableOnChangedEvent<T extends Record<string, any> = any> = SmartTableOnChangedEventToEmit<T> & SmartTableOnChangedEventBase<T>;
 export {};

package/lib/ng2-smart-table.component.d.ts

@@ -1,11 +1,11 @@
-import { OnChanges, OnDestroy, SimpleChange } from "@angular/core";
-import { Row } from "./lib/data-set/row";
-import { LocalDataSource } from "./lib/data-source/local/local.data-source";
-import { Grid } from "./lib/grid";
-import { ColumnPositionState, SmartTableConfirmDeleteEvent, SmartTableConfirmEditEvent, SmartTableCreateConfirm, SmartTableCustomEvent, SmartTableRowClickedEvent, SmartTableRowSelectEvent, SmartTableSettings } from "./lib/interfaces/smart-table.models";
+import { OnChanges, OnDestroy, SimpleChange } from '@angular/core';
+import { Row } from './lib/data-set/row';
+import { DataSource } from './lib/data-source/data-source';
+import { Grid } from './lib/grid';
+import { ColumnPositionState, SmartTableConfirmDeleteEvent, SmartTableConfirmEditEvent, SmartTableCreateConfirm, SmartTableCustomEvent, SmartTableRowClickedEvent, SmartTableRowSelectEvent, SmartTableSettings } from './lib/interfaces/smart-table.models';
 import * as i0 from "@angular/core";
 export declare class Ng2SmartTableComponent implements OnChanges, OnDestroy {
-    readonly source: import("@angular/core").InputSignal<LocalDataSource<any>>;
+    readonly source: import("@angular/core").InputSignal<DataSource<any>>;
     readonly settings: import("@angular/core").InputSignal<SmartTableSettings<any>>;
     readonly multiRowSelect: import("@angular/core").OutputEmitterRef<SmartTableRowSelectEvent<any>>;
     readonly rowClicked: import("@angular/core").OutputEmitterRef<SmartTableRowClickedEvent>;
@@ -20,7 +20,6 @@ export declare class Ng2SmartTableComponent implements OnChanges, OnDestroy {
     readonly createConfirm: import("@angular/core").OutputEmitterRef<SmartTableCreateConfirm<any>>;
     protected readonly tableClass: import("@angular/core").Signal<string>;
     protected readonly tableId: import("@angular/core").Signal<string>;
-    protected readonly perPageSelect: import("@angular/core").Signal<number[]>;
     protected readonly isPagerDisplay: import("@angular/core").Signal<boolean>;
     protected readonly rowClassFunction: import("@angular/core").Signal<(row: any) => string>;
     grid: Grid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@den4ik92/ng2-smart-table",
-  "version": "19.1.6",
+  "version": "19.2.1",
   "description": "Angular Smart Table",
   "author": "Den4ik92",
   "license": "MIT",

package/public-api.d.ts

@@ -1,11 +1,12 @@
-export { DefaultEditor, Editor } from "./lib/components/cell/cell-editors/default-editor";
-export { DefaultFilter, Filter } from "./lib/components/filter/filter-types/default-filter";
-export { SmartTableColumnEditorDirective } from "./lib/components/table-columns-editor/column-editor.directive";
-export { Cell } from "./lib/lib/data-set/cell";
-export { Column } from "./lib/lib/data-set/column";
-export { Row } from "./lib/lib/data-set/row";
-export { DataSource } from "./lib/lib/data-source/data-source";
-export { LocalDataSource } from "./lib/lib/data-source/local/local.data-source";
-export { Deferred } from "./lib/lib/helpers";
-export * from "./lib/lib/interfaces/smart-table.models";
-export * from "./lib/ng2-smart-table.component";
+export { BaseEditorComponent, Editor } from './lib/components/cell/cell-editors/base-editor.component';
+export { BaseFilterComponent, FilterComponent } from './lib/components/filter/filter-types/base-filter.component';
+export { SmartTableColumnEditorDirective } from './lib/components/table-columns-editor/column-editor.directive';
+export { Cell } from './lib/lib/data-set/cell';
+export { Column } from './lib/lib/data-set/column';
+export { Row } from './lib/lib/data-set/row';
+export { DataSource } from './lib/lib/data-source/data-source';
+export { LocalDataSource } from './lib/lib/data-source/local/local.data-source';
+export { ParamsPrepareFunction, RequestFunction, ServerDataSource } from './lib/lib/data-source/server/server.data-source';
+export { Deferred } from './lib/lib/helpers';
+export * from './lib/lib/interfaces/smart-table.models';
+export * from './lib/ng2-smart-table.component';

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

@@ -1,9 +0,0 @@
-import { SmartTableEditorAndFilterTypes } from "../../../lib/interfaces/smart-table.models";
-import { EditCellDefaultComponent } from "./edit-cell-default";
-import * as i0 from "@angular/core";
-export declare class DefaultEditComponent extends EditCellDefaultComponent {
-    constructor();
-    getEditorType(): SmartTableEditorAndFilterTypes;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultEditComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultEditComponent, "ng2-table-cell-default-editor", never, {}, {}, never, never, true, never>;
-}

package/lib/components/cell/cell-edit-mode/edit-cell-default.d.ts

@@ -1,8 +0,0 @@
-import { Cell } from '../../../lib/data-set/cell';
-import * as i0 from "@angular/core";
-export declare class EditCellDefaultComponent {
-    readonly cell: import("@angular/core").InputSignal<Cell>;
-    readonly inputClass: import("@angular/core").InputSignal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EditCellDefaultComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<EditCellDefaultComponent, "ng2-edit-cell-default-base-component", never, { "cell": { "alias": "cell"; "required": true; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/lib/components/cell/cell-editors/default-editor.d.ts

@@ -1,13 +0,0 @@
-import { InputSignal } from "@angular/core";
-import { Cell } from "../../../lib/data-set/cell";
-import * as i0 from "@angular/core";
-export declare class DefaultEditor implements Editor {
-    readonly cell: InputSignal<Cell>;
-    readonly inputClass: InputSignal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultEditor, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultEditor, "ng2-default-editor-base-component", never, { "cell": { "alias": "cell"; "required": true; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-export interface Editor {
-    cell: InputSignal<Cell>;
-    inputClass: InputSignal<string>;
-}

package/lib/components/filter/default-filter.component.d.ts

@@ -1,6 +0,0 @@
-import { FilterDefault } from "./filter-default";
-import * as i0 from "@angular/core";
-export declare class DefaultFilterComponent extends FilterDefault {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFilterComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultFilterComponent, "ng2-default-table-filter", never, {}, {}, never, never, true, never>;
-}

package/lib/components/filter/filter-default.d.ts

@@ -1,13 +0,0 @@
-import { Column } from '../../lib/data-set/column';
-import { LocalDataSource } from '../../lib/data-source/local/local.data-source';
-import * as i0 from "@angular/core";
-export declare class FilterDefault {
-    readonly column: import("@angular/core").InputSignal<Column>;
-    readonly source: import("@angular/core").InputSignal<LocalDataSource<any>>;
-    readonly inputClass: import("@angular/core").InputSignal<string>;
-    query: string;
-    readonly filter: import("@angular/core").OutputEmitterRef<any>;
-    onFilter(query: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FilterDefault, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FilterDefault, "ng2-filter-default-component", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; }; }, { "filter": "filter"; }, never, never, true, never>;
-}

package/lib/components/filter/filter-types/default-filter.d.ts

@@ -1,27 +0,0 @@
-import { EventEmitter, InputSignal, OnDestroy, OutputEmitterRef } from '@angular/core';
-import { Subscription } from 'rxjs';
-import { LocalDataSource } from 'ng2-smart-table';
-import { Column } from '../../../lib/data-set/column';
-import * as i0 from "@angular/core";
-export declare class DefaultFilter implements Filter, OnDestroy {
-    delay: number;
-    changesSubscription?: Subscription;
-    query: string;
-    readonly inputClass: InputSignal<string>;
-    readonly source: InputSignal<LocalDataSource<any>>;
-    readonly column: InputSignal<Column>;
-    readonly filter: OutputEmitterRef<string>;
-    ngOnDestroy(): void;
-    setFilter(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFilter, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DefaultFilter, "ng2-default-base-filter-component", never, { "query": { "alias": "query"; "required": false; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "column": { "alias": "column"; "required": true; "isSignal": true; }; }, { "filter": "filter"; }, never, never, true, never>;
-}
-export interface Filter {
-    delay?: number;
-    changesSubscription?: Subscription;
-    query: string;
-    inputClass: InputSignal<string>;
-    source: InputSignal<LocalDataSource>;
-    column: InputSignal<Column>;
-    filter: EventEmitter<string> | OutputEmitterRef<any>;
-}