@den4ik92/ng2-smart-table 1.0.0

package/lib/components/thead/rows/thead-filters-row.component.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { Grid } from '../../../lib/grid';
+import { DataSource } from '../../../lib/data-source/data-source';
+import { Column } from "../../../lib/data-set/column";
+import * as i0 from "@angular/core";
+export declare class TheadFitlersRowComponent implements OnChanges {
+    grid: Grid;
+    source: DataSource;
+    create: EventEmitter<any>;
+    filter: EventEmitter<any>;
+    isMultiSelectVisible: boolean;
+    showActionColumnLeft: boolean;
+    showActionColumnRight: boolean;
+    filterInputClass: string;
+    ngOnChanges(): void;
+    getVisibleColumns(columns: Array<Column>): Array<Column>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheadFitlersRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheadFitlersRowComponent, "[ng2-st-thead-filters-row]", never, { "grid": "grid"; "source": "source"; }, { "create": "create"; "filter": "filter"; }, never, never, false, never>;
+}

package/lib/components/thead/rows/thead-form-row.component.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { Grid } from '../../../lib/grid';
+import { Row } from '../../../lib/data-set/row';
+import { Cell } from '../../../lib/data-set/cell';
+import * as i0 from "@angular/core";
+export declare class TheadFormRowComponent implements OnChanges {
+    grid: Grid;
+    row: Row;
+    createConfirm: EventEmitter<any>;
+    create: EventEmitter<any>;
+    isMultiSelectVisible: boolean;
+    showActionColumnLeft: boolean;
+    showActionColumnRight: boolean;
+    addInputClass: string;
+    onCreate(event: any): void;
+    ngOnChanges(): void;
+    getVisibleCells(cells: Array<Cell>): Array<Cell>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheadFormRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheadFormRowComponent, "[ng2-st-thead-form-row]", never, { "grid": "grid"; "row": "row"; "createConfirm": "createConfirm"; }, { "create": "create"; }, never, never, false, never>;
+}

package/lib/components/thead/rows/thead-titles-row.component.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { Grid } from '../../../lib/grid';
+import { DataSource } from '../../../lib/data-source/data-source';
+import { Column } from "../../../lib/data-set/column";
+import * as i0 from "@angular/core";
+export declare class TheadTitlesRowComponent implements OnChanges {
+    grid: Grid;
+    source: DataSource;
+    sort: EventEmitter<any>;
+    selectAllRows: EventEmitter<any>;
+    isMultiSelectVisible: boolean;
+    showActionColumnLeft: boolean;
+    showActionColumnRight: boolean;
+    ngOnChanges(): void;
+    getVisibleColumns(columns: Array<Column>): Array<Column>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheadTitlesRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheadTitlesRowComponent, "[ng2-st-thead-titles-row]", never, { "grid": "grid"; "source": "source"; }, { "sort": "sort"; "selectAllRows": "selectAllRows"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,18 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { Grid } from '../../lib/grid';
+import { DataSource } from '../../lib/data-source/data-source';
+import * as i0 from "@angular/core";
+export declare class Ng2SmartTableTheadComponent implements OnChanges {
+    grid: Grid;
+    source: DataSource;
+    createConfirm: EventEmitter<any>;
+    sort: EventEmitter<any>;
+    selectAllRows: EventEmitter<any>;
+    create: EventEmitter<any>;
+    filter: EventEmitter<any>;
+    isHideHeader: boolean;
+    isHideSubHeader: boolean;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Ng2SmartTableTheadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Ng2SmartTableTheadComponent, "[ng2-st-thead]", never, { "grid": "grid"; "source": "source"; "createConfirm": "createConfirm"; }, { "sort": "sort"; "selectAllRows": "selectAllRows"; "create": "create"; "filter": "filter"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./cells/actions.component";
+import * as i2 from "./cells/actions-title.component";
+import * as i3 from "./cells/add-button.component";
+import * as i4 from "./cells/checkbox-select-all.component";
+import * as i5 from "./cells/column-title.component";
+import * as i6 from "./cells/title/title.component";
+import * as i7 from "./rows/thead-filters-row.component";
+import * as i8 from "./rows/thead-form-row.component";
+import * as i9 from "./rows/thead-titles-row.component";
+import * as i10 from "./thead.component";
+import * as i11 from "@angular/common";
+import * as i12 from "@angular/forms";
+import * as i13 from "../filter/filter.module";
+import * as i14 from "../cell/cell.module";
+export declare class THeadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<THeadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<THeadModule, [typeof i1.ActionsComponent, typeof i2.ActionsTitleComponent, typeof i3.AddButtonComponent, typeof i4.CheckboxSelectAllComponent, typeof i5.ColumnTitleComponent, typeof i6.TitleComponent, typeof i7.TheadFitlersRowComponent, typeof i8.TheadFormRowComponent, typeof i9.TheadTitlesRowComponent, typeof i10.Ng2SmartTableTheadComponent], [typeof i11.CommonModule, typeof i12.FormsModule, typeof i13.FilterModule, typeof i14.CellModule], [typeof i1.ActionsComponent, typeof i2.ActionsTitleComponent, typeof i3.AddButtonComponent, typeof i4.CheckboxSelectAllComponent, typeof i5.ColumnTitleComponent, typeof i6.TitleComponent, typeof i7.TheadFitlersRowComponent, typeof i8.TheadFormRowComponent, typeof i9.TheadTitlesRowComponent, typeof i10.Ng2SmartTableTheadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<THeadModule>;
+}

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

@@ -0,0 +1,20 @@
+import { Column } from './column';
+import { DataSet } from './data-set';
+import { Row } from './row';
+export declare function prepareValue(value: any): any;
+export declare class Cell {
+    protected value: any;
+    protected row: Row;
+    protected column: any;
+    protected dataSet: DataSet;
+    newValue: any;
+    protected static PREPARE: typeof prepareValue;
+    constructor(value: any, row: Row, column: any, dataSet: DataSet);
+    getColumn(): Column;
+    getRow(): Row;
+    getValue(): any;
+    setValue(value: any): any;
+    getId(): string;
+    getTitle(): string;
+    isEditable(): boolean;
+}

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

@@ -0,0 +1,44 @@
+import { DataSet } from './data-set';
+export declare class Column {
+    id: string;
+    protected settings: any;
+    protected dataSet: DataSet;
+    title: string;
+    type: string;
+    class: string;
+    width: string;
+    hide: boolean;
+    isSortable: boolean;
+    isEditable: boolean;
+    isAddable: boolean;
+    isFilterable: boolean;
+    sortDirection: string;
+    defaultSortDirection: string;
+    editor: {
+        type: string;
+        config: any;
+        component: any;
+    };
+    filter: {
+        type: string;
+        config: any;
+        component: any;
+    };
+    renderComponent: any;
+    compareFunction: Function;
+    valuePrepareFunction: Function;
+    filterFunction: Function;
+    onComponentInitFunction: Function;
+    constructor(id: string, settings: any, dataSet: DataSet);
+    getOnComponentInitFunction(): Function;
+    getCompareFunction(): Function;
+    getValuePrepareFunction(): Function;
+    getFilterFunction(): Function;
+    getConfig(): any;
+    getFilterType(): any;
+    getFilterConfig(): any;
+    protected process(): void;
+    prepareType(): string;
+    prepareSortDirection(): string;
+    determineType(): string;
+}

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

@@ -0,0 +1,37 @@
+import { Row } from './row';
+import { Column } from './column';
+export declare class DataSet {
+    protected columnSettings: Object;
+    newRow: Row;
+    protected data: Array<any>;
+    protected columns: Array<Column>;
+    protected rows: Array<Row>;
+    protected selectedRows: Set<Row>;
+    protected willSelect: string;
+    constructor(data: Array<any>, columnSettings: Object);
+    setData(data: Array<any>): void;
+    getColumns(): Array<Column>;
+    getRows(): Array<Row>;
+    getFirstRow(): Row;
+    getLastRow(): Row;
+    findRowByData(data: any): Row;
+    setSelectAll(state: boolean): void;
+    deselectAll(): void;
+    selectRow(row: Row, state: boolean): void;
+    multipleSelectRow(row: Row): Row;
+    getSelectedRowsData(): Array<any>;
+    createNewRow(): void;
+    /**
+     * Create columns by mapping from the settings
+     * @param settings
+     * @private
+     */
+    createColumns(settings: any): void;
+    /**
+     * Create rows based on current data prepared in data source
+     * @private
+     */
+    createRows(): void;
+    get isAllSelected(): boolean;
+    private storeSelectedRow;
+}

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

@@ -0,0 +1,20 @@
+import { Cell } from './cell';
+import { Column } from './column';
+import { DataSet } from './data-set';
+export declare class Row {
+    index: number;
+    protected data: any;
+    protected _dataSet: DataSet;
+    isSelected: boolean;
+    isInEditing: boolean;
+    cells: Array<Cell>;
+    constructor(index: number, data: any, _dataSet: DataSet);
+    getCell(column: Column): Cell;
+    getCells(): Cell[];
+    getData(): any;
+    getIsSelected(): boolean;
+    getNewData(): any;
+    setData(data: any): any;
+    process(): void;
+    createCell(column: Column): Cell;
+}

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

@@ -0,0 +1,35 @@
+import { Subject } from 'rxjs';
+import { Observable } from 'rxjs';
+export declare abstract class DataSource {
+    protected onChangedSource: Subject<any>;
+    protected onAddedSource: Subject<any>;
+    protected onUpdatedSource: Subject<any>;
+    protected onRemovedSource: Subject<any>;
+    abstract getAll(): Promise<any>;
+    abstract getElements(): Promise<any>;
+    abstract getSort(): any;
+    abstract getFilter(): any;
+    abstract getPaging(): any;
+    abstract count(): number;
+    refresh(): void;
+    load(data: Array<any>): Promise<any>;
+    onChanged(): Observable<any>;
+    onAdded(): Observable<any>;
+    onUpdated(): Observable<any>;
+    onRemoved(): Observable<any>;
+    prepend(element: any): Promise<any>;
+    append(element: any): Promise<any>;
+    add(element: any): Promise<any>;
+    remove(element: any): Promise<any>;
+    update(element: any, values: any): Promise<any>;
+    empty(): Promise<any>;
+    setSort(conf: Array<any>, doEmit?: boolean): void;
+    setFilter(conf: Array<any>, andOperator?: boolean, doEmit?: boolean): void;
+    addFilter(fieldConf: {}, andOperator?: boolean, doEmit?: boolean): void;
+    setPaging(page: number, perPage: number, doEmit?: boolean): void;
+    setPage(page: number, doEmit?: boolean): void;
+    protected emitOnRemoved(element: any): void;
+    protected emitOnUpdated(element: any): void;
+    protected emitOnAdded(element: any): void;
+    protected emitOnChanged(action: string): void;
+}

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

@@ -0,0 +1,55 @@
+import { DataSource } from '../data-source';
+export declare class LocalDataSource extends DataSource {
+    protected data: Array<any>;
+    protected filteredAndSorted: Array<any>;
+    protected sortConf: Array<any>;
+    protected filterConf: any;
+    protected pagingConf: any;
+    constructor(data?: Array<any>);
+    load(data: Array<any>): Promise<any>;
+    prepend(element: any): Promise<any>;
+    append(element: any): Promise<any>;
+    add(element: any): Promise<any>;
+    remove(element: any): Promise<any>;
+    update(element: any, values: any): Promise<any>;
+    find(element: any): Promise<any>;
+    getElements(): Promise<any>;
+    getFilteredAndSorted(): Promise<any>;
+    getAll(): Promise<any>;
+    reset(silent?: boolean): void;
+    empty(): Promise<any>;
+    count(): number;
+    /**
+     *
+     * Array of conf objects
+     * [
+     *  {field: string, direction: asc|desc|null, compare: Function|null},
+     * ]
+     * @param conf
+     * @param doEmit
+     * @returns {LocalDataSource}
+     */
+    setSort(conf: Array<any>, doEmit?: boolean): LocalDataSource;
+    /**
+     *
+     * Array of conf objects
+     * [
+     *  {field: string, search: string, filter: Function|null},
+     * ]
+     * @param conf
+     * @param andOperator
+     * @param doEmit
+     * @returns {LocalDataSource}
+     */
+    setFilter(conf: Array<any>, andOperator?: boolean, doEmit?: boolean): LocalDataSource;
+    addFilter(fieldConf: any, andOperator?: boolean, doEmit?: boolean): LocalDataSource;
+    setPaging(page: number, perPage: number, doEmit?: boolean): LocalDataSource;
+    setPage(page: number, doEmit?: boolean): LocalDataSource;
+    getSort(): any;
+    getFilter(): any;
+    getPaging(): any;
+    protected prepareData(data: Array<any>): Array<any>;
+    protected sort(data: Array<any>): Array<any>;
+    protected filter(data: Array<any>): Array<any>;
+    protected paginate(data: Array<any>): Array<any>;
+}

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

@@ -0,0 +1,4 @@
+export declare function filterValues(value: string, search: string): boolean;
+export declare class LocalFilter {
+    static filter(data: Array<any>, field: string, search: string, customFilter?: Function): Array<any>;
+}

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

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

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

@@ -0,0 +1,4 @@
+export declare function compareValues(direction: any, a: any, b: any): any;
+export declare class LocalSorter {
+    static sort(data: Array<any>, field: string, direction: string, customCompare?: Function): Array<any>;
+}

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

@@ -0,0 +1,27 @@
+export declare class ServerSourceConf {
+    protected static readonly SORT_FIELD_KEY = "_sort";
+    protected static readonly SORT_DIR_KEY = "_order";
+    protected static readonly PAGER_PAGE_KEY = "_page";
+    protected static readonly PAGER_LIMIT_KEY = "_limit";
+    protected static readonly FILTER_FIELD_KEY = "#field#_like";
+    protected static readonly TOTAL_KEY = "x-total-count";
+    protected static readonly DATA_KEY = "";
+    endPoint: string;
+    sortFieldKey: string;
+    sortDirKey: string;
+    pagerPageKey: string;
+    pagerLimitKey: string;
+    filterFieldKey: string;
+    totalKey: string;
+    dataKey: string;
+    constructor({ endPoint, sortFieldKey, sortDirKey, pagerPageKey, pagerLimitKey, filterFieldKey, totalKey, dataKey }?: {
+        endPoint?: string;
+        sortFieldKey?: string;
+        sortDirKey?: string;
+        pagerPageKey?: string;
+        pagerLimitKey?: string;
+        filterFieldKey?: string;
+        totalKey?: string;
+        dataKey?: string;
+    });
+}

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

@@ -0,0 +1,30 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { LocalDataSource } from '../local/local.data-source';
+import { ServerSourceConf } from './server-source.conf';
+export declare class ServerDataSource extends LocalDataSource {
+    protected http: HttpClient;
+    protected conf: ServerSourceConf;
+    protected lastRequestCount: number;
+    constructor(http: HttpClient, conf?: ServerSourceConf | {});
+    count(): number;
+    getElements(): Promise<any>;
+    /**
+     * Extracts array of data from server response
+     * @param res
+     * @returns {any}
+     */
+    protected extractDataFromResponse(res: any): Array<any>;
+    /**
+     * Extracts total rows count from the server response
+     * Looks for the count in the heders first, then in the response body
+     * @param res
+     * @returns {any}
+     */
+    protected extractTotalFromResponse(res: any): number;
+    protected requestElements(): Observable<any>;
+    protected createRequesParams(): HttpParams;
+    protected addSortRequestParams(httpParams: HttpParams): HttpParams;
+    protected addFilterRequestParams(httpParams: HttpParams): HttpParams;
+    protected addPagerRequestParams(httpParams: HttpParams): HttpParams;
+}

package/lib/lib/grid.d.ts

@@ -0,0 +1,49 @@
+import { Subject } from 'rxjs';
+import { Observable } from 'rxjs';
+import { EventEmitter } from '@angular/core';
+import { Column } from './data-set/column';
+import { Row } from './data-set/row';
+import { DataSet } from './data-set/data-set';
+import { DataSource } from './data-source/data-source';
+import { SmartTableSettings } from './interfaces/smart-table.models';
+export declare class Grid {
+    createFormShown: boolean;
+    source: DataSource;
+    settings: SmartTableSettings;
+    dataSet: DataSet;
+    onSelectRowSource: Subject<any>;
+    onDeselectRowSource: Subject<any>;
+    private sourceOnChangedSubscription;
+    private sourceOnUpdatedSubscription;
+    constructor(source: DataSource, settings: SmartTableSettings);
+    detach(): void;
+    showActionColumn(position: string): boolean;
+    isCurrentActionsPosition(position: string): boolean;
+    isActionsVisible(): boolean;
+    isMultiSelectVisible(): boolean;
+    getNewRow(): Row;
+    setSettings(settings: SmartTableSettings): void;
+    getDataSet(): DataSet;
+    setSource(source: DataSource): void;
+    getSetting(name: string, defaultValue?: any): any;
+    getColumns(): Array<Column>;
+    getRows(): Array<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>): void;
+    save(row: Row, confirmEmitter: EventEmitter<any>): void;
+    delete(row: Row, confirmEmitter: EventEmitter<any>): void;
+    processDataChange(changes: any): void;
+    shouldProcessChange(changes: any): boolean;
+    prepareSource(source: any): DataSource;
+    getInitialSort(): any;
+    getSelectedRowsData(): Array<any>;
+    selectAllRows(status: boolean): void;
+    getFirstRow(): Row;
+    getLastRow(): Row;
+    private getSelectionInfo;
+    private getPageToSelect;
+}

package/lib/lib/helpers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Extending object that entered in first argument.
+ *
+ * Returns extended object or false if have no target object or incorrect type.
+ *
+ * If you wish to clone source object (without modify it), just use empty new
+ * object as first argument, like this:
+ *   deepExtend({}, yourObj_1, [yourObj_N]);
+ */
+export declare const deepExtend: (...objects: Array<any>) => any;
+export declare class Deferred {
+    promise: Promise<any>;
+    resolve: any;
+    reject: any;
+    constructor();
+}
+export declare function getDeepFromObject(object: {}, name: string, defaultValue?: any): any;
+export declare function getPageForRowIndex(index: number, perPage: number): number;

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

@@ -0,0 +1,148 @@
+import { DataSource } from "../data-source/data-source";
+import { Deferred } from "../helpers";
+export interface SelectOption {
+    title: string;
+    value: number | string;
+}
+export interface SmartTableSettings<T = any> {
+    mode?: 'inline' | 'external' | 'click-to-edit';
+    selectMode?: 'single' | 'multi';
+    selectedRowIndex?: number;
+    switchPageToSelectedRowPage?: boolean;
+    hideHeader?: boolean;
+    hideSubHeader?: boolean;
+    actions?: SmartTableAction | false;
+    filter?: {
+        inputClass: string;
+    };
+    edit?: {
+        inputClass?: string;
+        editButtonContent?: string;
+        saveButtonContent?: string;
+        cancelButtonContent?: string;
+        confirmSave?: boolean;
+    } | false;
+    add?: {
+        inputClass?: string;
+        addButtonContent?: string;
+        createButtonContent?: string;
+        cancelButtonContent?: string;
+        confirmCreate?: boolean;
+    } | false;
+    delete?: {
+        deleteButtonContent?: string;
+        confirmDelete?: boolean;
+    } | false;
+    attr?: {
+        id?: string;
+        class?: string;
+    };
+    noDataMessage?: string;
+    columns: {
+        [key: string]: SmartTableColumn<T>;
+    };
+    pager?: {
+        display: boolean;
+        page?: number;
+        perPage: number;
+    } | false;
+    rowClassFunction?: (row: {
+        data: T;
+    }) => string;
+}
+export interface SmartTableAction {
+    columnTitle?: string;
+    add?: boolean;
+    edit?: boolean;
+    delete?: boolean;
+    custom?: SmartTableCustomAction[];
+    position?: 'left' | 'right';
+}
+export interface SmartTableCustomAction {
+    name: string;
+    title: string;
+}
+export type SmartTableColumn<T> = SmartTableTextHtmlColumn<T> | SmartTableCustomColumn<T>;
+interface SmartTableDefaultColumn<T> {
+    title: string;
+    width?: string;
+    class?: string;
+    editable?: boolean;
+    hide?: boolean;
+    sort?: boolean;
+    sortDirection?: 'desc' | 'asc' | false;
+    editor?: SmartTableEditorAndFilter;
+    filter?: SmartTableEditorAndFilter | false;
+    compareFunction?: (itemA: T, itemB: T) => number;
+    valuePrepareFunction?: (columnData: any, rowData: T) => any;
+    filterFunction?: (columnData: any, search: string) => boolean;
+}
+interface SmartTableTextHtmlColumn<T> extends SmartTableDefaultColumn<T> {
+    type: 'text' | 'html';
+}
+interface SmartTableCustomColumn<T> extends SmartTableDefaultColumn<T> {
+    type: 'custom';
+    renderComponent: any;
+}
+export type SmartTableEditorAndFilter = {
+    type: 'text' | 'textarea';
+} | SmartTableEditorList | SmartTableEditorCompleter | SmartTableEditorCheckbox | SmartTableEditorCustom;
+interface SmartTableEditorList {
+    type: 'list';
+    config: {
+        selectText?: string;
+        list: SelectOption[];
+    };
+}
+interface SmartTableEditorCompleter {
+    type: 'completer';
+    config: {
+        completer: {
+            data: any[];
+            searchFields: string;
+            titleField: string;
+            descriptionField?: string;
+        };
+    };
+}
+interface SmartTableEditorCustom {
+    type: 'custom';
+    component: any;
+    config?: any;
+}
+export interface SmartTableEditorCheckbox {
+    type: 'checkbox';
+    config?: {
+        true: string;
+        false: string;
+        resetText?: string;
+    };
+}
+export interface SmartTableFilterItem {
+    field: string;
+    search: string;
+}
+interface SmartTableDefaultEvent<T> {
+    confirm: Deferred;
+    data: T;
+    source: DataSource;
+}
+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"> {
+    action: string;
+}
+export interface SmartTableRowSelectEvent<T = any> extends Omit<SmartTableDefaultEvent<T>, "confirm"> {
+    isSelected: boolean;
+    selected: T[];
+}
+export interface SmartTableConfirmEditEvent<T = any> extends SmartTableDefaultEvent<T> {
+    newData: T;
+}
+export interface SmartTableCreateConfirm<T = any> extends Omit<SmartTableDefaultEvent<T>, "data"> {
+    newData: T;
+}
+export interface ObjectStringString {
+    [key: string]: string;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import { SimpleChange, EventEmitter, OnChanges } from '@angular/core';
+import { Grid } from './lib/grid';
+import { DataSource } from './lib/data-source/data-source';
+import { Row } from './lib/data-set/row';
+import { 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 {
+    source: DataSource;
+    settings: SmartTableSettings;
+    multiRowSelect: EventEmitter<SmartTableRowSelectEvent<any>>;
+    rowClicked: EventEmitter<SmartTableRowClickedEvent<any>>;
+    delete: EventEmitter<any>;
+    edit: EventEmitter<any>;
+    create: EventEmitter<any>;
+    custom: EventEmitter<SmartTableCustomEvent<any>>;
+    deleteConfirm: EventEmitter<SmartTableConfirmDeleteEvent<any>>;
+    editConfirm: EventEmitter<SmartTableConfirmEditEvent<any>>;
+    createConfirm: EventEmitter<SmartTableCreateConfirm<any>>;
+    rowHover: EventEmitter<any>;
+    tableClass: string;
+    tableId: string;
+    perPageSelect: any;
+    isHideHeader: boolean;
+    isHideSubHeader: boolean;
+    isPagerDisplay: boolean;
+    rowClassFunction: Function;
+    grid: Grid;
+    defaultSettings: SmartTableSettings;
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    onRowHover(row: Row): void;
+    multipleSelectRow(row: Row): void;
+    onSelectAllRows(): void;
+    onSelectRow(row: Row, state: boolean): void;
+    initGrid(): void;
+    prepareSource(): DataSource;
+    prepareSettings(): SmartTableSettings;
+    private emitUserSelectRow;
+    emitUserRowClicked(row: Row): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Ng2SmartTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Ng2SmartTableComponent, "ng2-smart-table", never, { "source": "source"; "settings": "settings"; }, { "multiRowSelect": "multiRowSelect"; "rowClicked": "rowClicked"; "delete": "delete"; "edit": "edit"; "create": "create"; "custom": "custom"; "deleteConfirm": "deleteConfirm"; "editConfirm": "editConfirm"; "createConfirm": "createConfirm"; "rowHover": "rowHover"; }, never, never, false, never>;
+}