@zeedhi/common 1.111.1 → 3.0.0

package/dist/types/components/tek-grid/tek-datasource/interfaces.d.ts

@@ -0,0 +1,16 @@
+import { IDictionary, IMemoryDatasource, IRestDatasource } from '@zeedhi/core';
+export interface ITekMemoryDatasource extends IMemoryDatasource {
+    dynamicFilter?: IDictionary<any>;
+    searchJoin?: IDictionary<Array<string | number>>;
+}
+export interface ITekRestDatasource extends IRestDatasource {
+    dynamicFilter?: IDictionary<any>;
+    searchJoin?: IDictionary<Array<string | number>>;
+}
+export interface IDynamicFilterItem {
+    relation: string;
+    operation: string;
+    value: any;
+}
+export declare const DynamicFilterOperations: IDictionary<boolean>;
+export declare const DynamicFilterRelations: IDictionary<boolean>;

package/dist/types/components/tek-grid/tek-datasource/tek-memory-datasource.d.ts

@@ -0,0 +1,93 @@
+import { IDatasource, IDictionary, MemoryDatasource } from '@zeedhi/core';
+import { IDynamicFilterItem, ITekMemoryDatasource } from './interfaces';
+export declare class TekMemoryDatasource extends MemoryDatasource implements ITekMemoryDatasource {
+    /** Dynamic filter data */
+    dynamicFilter: IDictionary<IDynamicFilterItem[]>;
+    /** Search Join data */
+    searchJoin: IDictionary<Array<string | number>>;
+    /**
+     * Dynamic Filter Operations
+     */
+    dynamicFilterOperations: IDictionary<boolean>;
+    /**
+     * Dynamic Filter Relations
+     */
+    dynamicFilterRelations: IDictionary<boolean>;
+    /**
+     * Dynamic Filter applied flag
+     */
+    protected dynamicFilterApplied: string;
+    /**
+     * Create new datasource
+     * @param props Datasource properties
+     */
+    constructor(props: ITekMemoryDatasource);
+    protected updateReservedKeys(): void;
+    protected updateInternalProperties(datasource?: IDatasource): void;
+    protected getEncodedParam(urlParam: string, datasourceParam?: IDictionary<any>): IDictionary<any>;
+    protected getQueryStringValues(): IDictionary<any>;
+    protected getUrlQueryString(): string;
+    /**
+     * Adds a new dynamic filter position or replace if exists
+     * @param column Dynamic Filter column name
+     * @param value Dynamic Filter value
+     * @returns Promise with data collection
+     */
+    addDynamicFilter(column: string, value: any): Promise<any>;
+    /**
+     * Removes a dynamic filter position
+     * @param column Dynamic Filter column name
+     * @returns Promise with data collection
+     */
+    removeDynamicFilter(column: string): Promise<any>;
+    /**
+     * Sets new dynamic filter value
+     * @param filter Dynamic Filter value
+     * @returns Promise with data collection
+     */
+    setDynamicFilter(filter: IDictionary<any>): Promise<any>;
+    /**
+     * Clears Dynamic filter value
+     * @returns Promise with data collection
+     */
+    clearDynamicFilter(): Promise<any>;
+    /**
+     * Resets page and selected rows and tries to update the url
+     * @returns Promise with data collection
+     */
+    updateDynamicFilter(): Promise<any>;
+    /**
+     * Checks if a filter value is valid
+     * @param value Filter value
+     * @returns Is valid filter value
+     */
+    protected isValidDynamicFilterValue(column: string, value?: IDictionary<any>[]): boolean | undefined;
+    clone(): {
+        dynamicFilter: IDictionary<IDynamicFilterItem[]>;
+        searchJoin: IDictionary<(string | number)[]>;
+        type: string;
+        translate?: boolean | string[] | undefined;
+        sortFunction?: ((value1: any, value2: any, columnName: string) => boolean) | undefined;
+        sortParams?: IDictionary<any> | undefined;
+        currentRow?: IDictionary<any> | undefined;
+        data?: IDictionary<any>[] | undefined;
+        filter?: IDictionary<any> | undefined;
+        limit?: string | number | undefined;
+        loadAll?: boolean | undefined;
+        loading?: boolean | undefined;
+        order?: string[] | undefined;
+        page?: string | number | undefined;
+        search?: string | undefined;
+        searchIn?: string[] | undefined;
+        uniqueKey?: string | undefined;
+        watchUrl?: boolean | undefined;
+        events?: import("@zeedhi/core").IDatasourceEvents<import("@zeedhi/core").IEventParam<any>> | undefined;
+    };
+    /**
+     * Updates filtered data
+     */
+    protected updateFilteredData(): void;
+    protected getRowByDynamicFilter(row: IDictionary<any>): any;
+    protected getRowBySearchJoin(row: IDictionary<any>): boolean;
+    hasFilter(columnName: string): boolean;
+}

package/dist/types/components/tek-grid/tek-datasource/tek-rest-datasource.d.ts

@@ -0,0 +1,95 @@
+import { IDatasource, IDictionary, RestDatasource } from '@zeedhi/core';
+import { IDynamicFilterItem, ITekRestDatasource } from './interfaces';
+export declare class TekRestDatasource extends RestDatasource implements ITekRestDatasource {
+    /** Dynamic filter data */
+    dynamicFilter: IDictionary<IDynamicFilterItem[]>;
+    /** Search Join data */
+    searchJoin: IDictionary<Array<string | number>>;
+    /**
+     * Dynamic Filter Operations
+     */
+    dynamicFilterOperations: IDictionary<boolean>;
+    /**
+     * Dynamic Filter Relations
+     */
+    dynamicFilterRelations: IDictionary<boolean>;
+    /**
+     * Dynamic Filter applied flag
+     */
+    protected dynamicFilterApplied: string;
+    /**
+     * Create new datasource
+     * @param props Datasource properties
+     */
+    constructor(props: ITekRestDatasource);
+    protected updateReservedKeys(): void;
+    protected updateInternalProperties(datasource?: IDatasource): void;
+    protected getEncodedParam(urlParam: string, datasourceParam?: IDictionary<any>): IDictionary<any>;
+    protected getQueryStringValues(): IDictionary<any>;
+    protected getUrlQueryString(): string;
+    /**
+     * Adds a new dynamic filter position or replace if exists
+     * @param column Dynamic Filter column name
+     * @param value Dynamic Filter value
+     * @returns Promise with data collection
+     */
+    addDynamicFilter(column: string, value: any): Promise<IDictionary<any> | IDictionary<any>[]>;
+    /**
+     * Removes a dynamic filter position
+     * @param column Dynamic Filter column name
+     * @returns Promise with data collection
+     */
+    removeDynamicFilter(column: string): Promise<IDictionary<any> | IDictionary<any>[]>;
+    /**
+     * Sets new dynamic filter value
+     * @param filter Dynamic Filter value
+     * @returns Promise with data collection
+     */
+    setDynamicFilter(filter: IDictionary<any>): Promise<IDictionary<any> | IDictionary<any>[]>;
+    /**
+     * Clears Dynamic filter value
+     * @returns Promise with data collection
+     */
+    clearDynamicFilter(): Promise<IDictionary<any> | IDictionary<any>[]>;
+    /**
+     * Resets page and selected rows and tries to update the url
+     * @returns Promise with data collection
+     */
+    updateDynamicFilter(): Promise<IDictionary<any> | IDictionary<any>[]>;
+    /**
+     * Checks if a filter value is valid
+     * @param value Filter value
+     * @returns Is valid filter value
+     */
+    protected isValidDynamicFilterValue(column: string, value?: IDictionary<any>[]): boolean | undefined;
+    /**
+     * Retrieves request params
+     */
+    protected getRequestParams(): any;
+    hasFilter(columnName: string): boolean;
+    clone(): {
+        dynamicFilter: IDictionary<IDynamicFilterItem[]>;
+        searchJoin: IDictionary<(string | number)[]>;
+        type: string;
+        route?: string | undefined;
+        lazyLoad?: boolean | undefined;
+        arrayFormat?: import("@zeedhi/core").ArrayFormatType | undefined;
+        find?: IDictionary<any> | undefined;
+        localSearch?: boolean | undefined;
+        currentRow?: IDictionary<any> | undefined; /** Search Join data */
+        data?: IDictionary<any>[] | undefined;
+        filter?: IDictionary<any> | undefined;
+        limit?: string | number | undefined;
+        loadAll?: boolean | undefined;
+        loading?: boolean | undefined;
+        order?: string[] | undefined;
+        page?: string | number | undefined;
+        search?: string | undefined;
+        searchIn?: string[] | undefined;
+        uniqueKey?: string | undefined;
+        watchUrl?: boolean | undefined; /**
+         * Dynamic Filter applied flag
+         */
+        events?: import("@zeedhi/core").IDatasourceEvents<import("@zeedhi/core").IEventParam<any>> | undefined;
+    };
+}

package/dist/types/components/tek-grid/tek-grid-column.d.ts

@@ -0,0 +1,42 @@
+import { IDictionary } from '@zeedhi/core';
+import { GridColumnEditable } from '..';
+import { IFilterPropsComponent, ITekGridColumn, ITekGridColumnAggregation } from './interfaces';
+import { TekGrid } from './tek-grid';
+/**
+ * Base class for TekGrid column
+ */
+export declare class TekGridColumn extends GridColumnEditable implements ITekGridColumn {
+    filterProps: IFilterPropsComponent | IFilterPropsComponent[];
+    filterable: boolean;
+    filterIndex?: number;
+    skipLookupSearch: boolean;
+    private groupedValue;
+    private groupOpenedValue?;
+    groupLabelForEmptyValue: string;
+    private aggregationValue?;
+    private isVisibleValue;
+    /**
+     * Defines if the column should store the componentProps datasource.data in memory
+     */
+    storeData: boolean;
+    private grid;
+    /**
+     * Creates a new TekGrid Column.
+     * @param props TekGrid column properties
+     */
+    constructor(props: ITekGridColumn, grid: TekGrid);
+    getBatchLookupData(lookupColumn: string, values: any[]): Promise<IDictionary[]>;
+    /**
+     * Memory search, without changing lookupDatasource
+     */
+    memorySearch(search: string): Promise<any>;
+    get grouped(): boolean;
+    set grouped(value: boolean);
+    get aggregation(): ITekGridColumnAggregation;
+    set aggregation(value: ITekGridColumnAggregation);
+    get groupOpened(): boolean | undefined;
+    set groupOpened(value: boolean | undefined);
+    get isVisible(): boolean;
+    set isVisible(value: boolean);
+    private changeGrouping;
+}

package/dist/types/components/tek-grid/tek-grid-columns-button/tek-grid-columns-button-controller.d.ts

@@ -0,0 +1,8 @@
+import { IEventParam } from '@zeedhi/core';
+import { Checkbox, IterableColumnsButtonController } from '../..';
+import { TekGridColumn } from '../tek-grid-column';
+export declare class TekGridColumnsButtonController extends IterableColumnsButtonController {
+    changeGroupedColumn(column: TekGridColumn, { component, event, element }: IEventParam<Checkbox>): void;
+    changeAggregationColumn(column: TekGridColumn, { component, event, element }: IEventParam<Checkbox>): void;
+    showHideTekColumn(column: TekGridColumn, { component, event, element }: IEventParam<Checkbox>): void;
+}

package/dist/types/components/tek-grid/tek-grid-columns-button/tek-grid-columns-button.d.ts

@@ -0,0 +1,12 @@
+import { IterableColumnsButton, TekGridColumn } from '../..';
+import { ITekGridColumnsButton } from '../interfaces';
+/**
+ * Base class for TekGrid Columns Button component
+ */
+export declare class TekGridColumnsButton extends IterableColumnsButton<TekGridColumn> implements ITekGridColumnsButton {
+    hideGroups: boolean;
+    constructor(props: ITekGridColumnsButton);
+    onCreated(): void;
+    private aggregationDataSet;
+    getAggregationSelectData(): any[];
+}

package/dist/types/components/tek-grid/tek-grid-controller.d.ts

@@ -0,0 +1,31 @@
+import { IGridEditable } from '../zd-grid-editable';
+import { ISupportsToolbar } from './interfaces';
+export declare class TekGridController {
+    private grid;
+    openToolbar: boolean;
+    constructor(grid: IGridEditable & ISupportsToolbar);
+    get gridTitle(): string;
+    get showAddButton(): boolean;
+    get showDeleteButton(): boolean;
+    get showFilterButton(): boolean;
+    get showModalFilterProps(): import("./interfaces").IModalFilterProps;
+    get showSearchInput(): boolean;
+    get showToolbar(): boolean;
+    set showToolbar(value: boolean);
+    get toolbarClass(): string;
+    get tooltipName(): "TEKGRID_SHOW" | "TEKGRID_HIDE";
+    get showReloadButton(): boolean;
+    get showDivider2(): boolean;
+    get showColumnsButton(): boolean;
+    get columnsButtonIgnore(): string[];
+    get showLayoutOptionsButton(): boolean;
+    get showDivider1(): boolean;
+    get showActionsButton(): boolean;
+    get showExportButton(): boolean;
+    get showActionAndExportButton(): boolean;
+    get showDivider3(): boolean;
+    get isEditing(): boolean;
+    get showEditButtons(): boolean;
+    get isNotEditing(): boolean;
+    get disableDeleteButton(): boolean;
+}

package/dist/types/components/tek-grid/tek-grid-events.d.ts

@@ -0,0 +1,31 @@
+import { IDictionary } from '@zeedhi/core';
+import { GridEditableEvents } from '../zd-grid-editable';
+import { ITekGrid, ITekGridEvents, ITekGridSummary } from './interfaces';
+import { TekGridColumn } from './tek-grid-column';
+export declare class TekGridEvents extends GridEditableEvents implements ITekGridEvents {
+    protected tekGrid: ITekGrid;
+    /**
+     * Flag to prevent row click
+     */
+    protected preventRowClick: boolean;
+    protected preventRowDoubleClick: boolean;
+    constructor(tekGrid: ITekGrid);
+    calcSummary(column: TekGridColumn, summary: ITekGridSummary, row: IDictionary): void;
+    rowDoubleClick(row: IDictionary<any>, event: Event, element: HTMLElement): void;
+    /**
+     * Dispatches group row click event
+     * @param row Grid row
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    groupRowClick(row: IDictionary<any>, event: Event, element: HTMLElement): void;
+    groupRowDoubleClick(row: IDictionary<any>, event: Event, element: HTMLElement): void;
+    /**
+     * Dispatches group select/unselect event
+     * @param row Group row
+     * @param isSelected Row is selected
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    selectGroupClick(row: IDictionary<any>, isSelected: boolean, event: Event, element: HTMLElement): void;
+}

package/dist/types/components/tek-grid/tek-grid-toolbar-provider/export-options/button-option.d.ts

@@ -0,0 +1,17 @@
+import { IComponent } from '../../../zd-component/interfaces';
+import { IExportable, ITekGridExportConfig } from '../../interfaces';
+import { IExportOption } from './interfaces';
+export declare class ButtonOption implements IExportOption {
+    private config;
+    constructor(config: ITekGridExportConfig);
+    buildComponent(grid: IComponent & IExportable): {
+        label: string | undefined;
+        iconName: string | undefined;
+        name: string;
+        component: string;
+        flat: boolean;
+        events: {
+            click: () => any;
+        };
+    };
+}

package/dist/types/components/tek-grid/tek-grid-toolbar-provider/export-options/index.d.ts

@@ -0,0 +1,3 @@
+export * from './button-option';
+export * from './multi-option';
+export * from './interfaces';

package/dist/types/components/tek-grid/tek-grid-toolbar-provider/export-options/interfaces.d.ts

@@ -0,0 +1,5 @@
+import { IComponent, IComponentRender } from '../../../zd-component/interfaces';
+import { IExportable } from '../../interfaces';
+export interface IExportOption {
+    buildComponent: (grid: IComponent & IExportable) => IComponentRender;
+}

package/dist/types/components/tek-grid/tek-grid-toolbar-provider/export-options/multi-option.d.ts

@@ -0,0 +1,12 @@
+import { IComponent, IRow } from '../../../';
+import { IExportable, ITekGridExportConfig } from '../../interfaces';
+import { IExportOption } from './interfaces';
+export declare class MultiOption implements IExportOption {
+    private config;
+    constructor(config: ITekGridExportConfig);
+    private formatName;
+    private buildTooltip;
+    private buildButton;
+    private buildDivider;
+    buildComponent(grid: IComponent & IExportable): IRow;
+}

package/dist/types/components/tek-grid/tek-grid-toolbar-provider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './export-options';
+export * from './tek-grid-toolbar-provider';

package/dist/types/components/tek-grid/tek-grid-toolbar-provider/tek-grid-toolbar-provider.d.ts

@@ -0,0 +1,23 @@
+import { IEventParam } from '@zeedhi/core';
+import { IComponentRender } from '../../zd-component/interfaces';
+import { IGridEditable } from '../../zd-grid-editable';
+import { IExportable, ISupportsToolbar, ITekGridAtoms, ITekGridToolbarProvider } from '../interfaces';
+type GridEditableWithToolbar = IGridEditable & ISupportsToolbar & IExportable;
+export declare class TekGridToolbarProvider implements ITekGridToolbarProvider {
+    private grid;
+    private groupsVisibility;
+    constructor(grid: GridEditableWithToolbar, groupsVisibility: 'hide' | 'show');
+    protected atoms: ITekGridAtoms;
+    getAtomName(key: keyof ITekGridAtoms): string;
+    getAtomInstance<T>(key: keyof ITekGridAtoms): T;
+    private getOption;
+    private getExportConfigButtons;
+    private hideButtonClick;
+    private cancelChanges;
+    private saveChanges;
+    private addButtonClick;
+    private deleteButtonClick;
+    reloadGrid({ event }: IEventParam<any>): void;
+    getProperties(): IComponentRender[];
+}
+export {};

package/dist/types/components/tek-grid/tek-grid.d.ts

@@ -0,0 +1,220 @@
+import { Datasource, IDictionary, IEventParam } from '@zeedhi/core';
+import { IIterableProps } from '..';
+import { IComponent, IComponentRender } from '../zd-component/interfaces';
+import { Direction, IGrid, VerticalDirection } from '../zd-grid';
+import { IGridColumnEditable, IGridEditable } from '../zd-grid-editable';
+import { Iterable } from '../zd-iterable/iterable';
+import { IModalFilterProps, ITekGrid, ITekGridAtoms, ITekGridColumn, ITekGridExportConfig, ITekGridProps, ITekGridSummary } from './interfaces';
+import { TekGridColumn } from './tek-grid-column';
+export declare class TekGrid extends Iterable<TekGridColumn> implements ITekGrid {
+    private tableActionBuilder;
+    private iterableTable;
+    private dataSelector;
+    private tekGridEvents;
+    private dataNavigator;
+    private groupedViewNavigator;
+    private keyMapMerger;
+    private dataEditor;
+    private columnsSearcher;
+    private groupedDataManager;
+    private tekGridToolbarProvider;
+    title: string;
+    addButton: boolean;
+    deleteButton: 'none' | 'currentRow' | 'selection';
+    actions: IComponentRender[];
+    showEditButtons: boolean;
+    filterButton: boolean;
+    showSearch: boolean;
+    columnFilterButton: boolean;
+    columnsButton: boolean;
+    mainGrid: boolean;
+    columnsButtonIgnore: string[];
+    /**
+     * Enables column dragging
+     * @public
+     */
+    dragColumns: boolean;
+    /**
+     * Enables column resizing
+     * @public
+     */
+    resizeColumns: boolean;
+    /**
+     * Enables layout saving
+     * @public
+     */
+    showLayoutOptions: boolean;
+    xlsDefaultType?: string;
+    modalFilterProps: IModalFilterProps;
+    /**
+     * Show export button
+     */
+    showExport: boolean;
+    /**
+     * Show refresh button
+     */
+    showReload: boolean;
+    /**
+     * Export config
+     */
+    exportConfig: ITekGridExportConfig[];
+    /**
+     * Actions to overwrite the default export config
+     */
+    exportActions?: IComponentRender[];
+    /**
+     * Groups should be opened by default after building
+     */
+    groupsOpened: boolean;
+    /**
+     * Show Total summary
+     */
+    showSummaryTotal: boolean;
+    editNewRowsOnly: boolean;
+    protected keyShortcutKeyMapping: any;
+    showCheckboxAllFilter: boolean;
+    defaultFilter: IDictionary;
+    toolbarOpened: boolean;
+    reportTitle: string;
+    editing: boolean;
+    currentColumn: TekGridColumn | null;
+    selectedRows: IDictionary<any>[];
+    selectionState: {
+        allSelected: boolean;
+        except: IDictionary<any>[];
+    };
+    rowStyleConditions?: (row: IDictionary) => IDictionary;
+    selectAllPages: boolean;
+    selectable: boolean;
+    disableSelection?: (args: {
+        row: IDictionary<any>;
+        component: IGrid;
+    }) => boolean;
+    cellSelection: boolean;
+    toolbarSlot: IComponentRender[];
+    footerSlot: IComponentRender[];
+    noResultsText: string;
+    noResultSlot: IComponentRender[];
+    errorSlot: IComponentRender[];
+    dense: boolean;
+    headerBackground: string;
+    headerCellTextColor: string;
+    height: string | number;
+    loadingText: string;
+    maxHeight: string | number;
+    maxWidth: string | number;
+    minHeight: string | number;
+    minWidth: string | number;
+    noDataText: string;
+    noDataSlot: IComponentRender[];
+    showFooter: boolean;
+    showHeader: boolean;
+    showSelectAll: boolean;
+    width: string | number;
+    backgroundColor: string;
+    canEditRow?: ((args: {
+        row: IDictionary<any>;
+        component: IGridEditable;
+    }) => boolean) | undefined;
+    showCancelColumn: boolean;
+    doubleClickEdit: boolean;
+    singleEdit: boolean;
+    editingNewRows: boolean;
+    private defaultLazy;
+    private toolbarSlotProps;
+    filterRelationsDatasource?: Datasource;
+    filterOperationsDatasource?: Datasource;
+    /**
+     * TekGrid class constructor
+     * @param props TekGrid properties
+     */
+    constructor(props: ITekGridProps);
+    protected initializeDatasource(props: IIterableProps): void;
+    columnHasFilter(columnName: string): boolean;
+    registerTask(task: Promise<any>): void;
+    loadAfterTasks(): Promise<void>;
+    calcSummary(column: TekGridColumn, columnNamesummary: ITekGridSummary, row: IDictionary): void;
+    private getDefaultLazy;
+    initializeGrouping(lazyLoad: boolean): void;
+    updateGrouping(): void;
+    updateGroupedData(lazyLoad: boolean): Promise<void>;
+    buildGroupedData(): void;
+    openGroup(group: IDictionary<any>): void;
+    isItemVisible(row: IDictionary<any>): any;
+    isGrouped(): boolean;
+    isColumnSearchable(column: TekGridColumn): boolean;
+    getGroupedData(): IDictionary<any>[];
+    directionalLeft(param: IEventParam<any>): void;
+    directionalRight(param: IEventParam<any>): void;
+    getReport(): Promise<Window | null>;
+    setViewUpdateFixedColumns(fn: () => void): void;
+    setViewUpdateScrollData(fn: () => void): void;
+    onCreated(): void;
+    private createDynamicFilterDatasources;
+    onMounted(element: HTMLElement): void;
+    onBeforeDestroy(): void;
+    createColumn(column: ITekGridColumn): TekGridColumn;
+    getConditionalProps({ row, column }: {
+        row: IDictionary;
+        column: TekGridColumn;
+    }): Partial<IComponentRender>;
+    changeOrder(sortBy: {
+        key: string;
+        order: 'asc' | 'desc';
+    }[]): Promise<void>;
+    selectCell(row: IDictionary, column: TekGridColumn): void;
+    reapplyRowStyleConditions(row: IDictionary): IDictionary;
+    getRowStyleConditions(row: IDictionary): IDictionary;
+    deleteRows(): Promise<any[]>;
+    selectAll(isSelected: boolean): void;
+    toggleRow(row: IDictionary): void;
+    selectRow(row: IDictionary, select: boolean): void;
+    callDisableSelection(row: IDictionary): boolean;
+    selectClick(row: IDictionary<any>, isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAllClick(isSelected: boolean, event: Event, element?: HTMLElement): void;
+    navigatePageUp(): void;
+    navigatePageDown(): void;
+    setViewNavigate(viewNavigate: (direction: Direction, event?: Event) => void): void;
+    navigateLeft(params: IEventParam<any>): void;
+    navigateRight(params: IEventParam<any>): void;
+    navigateUp(): void;
+    navigateDown(): void;
+    navigateDatasource(direction: VerticalDirection): void;
+    getActionComponent(actionComponent: IComponent, column: TekGridColumn, row: IDictionary, parentPath?: string): IComponent;
+    addCancelColumn(): void;
+    getCancelColumnProps(): IGridColumnEditable;
+    isAdded(row: IDictionary): boolean;
+    cancelAddedRow(key: string | number): Promise<any>;
+    cancelAddedRows(): Promise<void>;
+    getAddedRows(): IDictionary<any>[];
+    addNewRow(row: IDictionary, position?: 'end' | 'start'): Promise<void>;
+    getVisibleValue(row: IDictionary, column: ITekGridColumn): any;
+    getEditableComponent(column: ITekGridColumn, row: IDictionary<any>): IComponentRender;
+    isEdited(column: ITekGridColumn, row: IDictionary): boolean;
+    isValid(column: ITekGridColumn, row: IDictionary, revalidate?: boolean): Promise<boolean>;
+    checkValid(column: ITekGridColumn, row: IDictionary): boolean;
+    isGridValid(revalidate?: boolean): boolean;
+    getComponent<T>(key: string, columnName: string): T;
+    updateRow(newRow: IDictionary): void;
+    updateCell(rowKey: string, columnName: string, value: any): void;
+    setViewEnterEdit(fn: ((rowKey: string, columnName: string) => void) | null): void;
+    enterEdit(rowKey: string, columnName: string): void;
+    cancelEditedRows(): Promise<void>;
+    saveEditedRows(revalidate?: boolean): Promise<void[]>;
+    reapplyCanEditRow(row: IDictionary<any>): void;
+    getCanEditRow(row: IDictionary<any>): boolean | undefined;
+    getEditedRows(revalidate?: boolean, silent?: boolean): IDictionary<any>[];
+    getEditedRow(row: IDictionary): IDictionary | undefined;
+    rowClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    rowDoubleClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    cellDoubleClick(row: IDictionary<any>, column: TekGridColumn, event: Event, element?: HTMLElement): void;
+    inlineEdit(row: IDictionary, column: TekGridColumn, event?: Event, element?: HTMLElement): void;
+    cellClick(row: IDictionary<any>, column: TekGridColumn, event: Event, element?: HTMLElement): void;
+    cellClickEvent(row: IDictionary<any>, column: TekGridColumn, event: Event, element?: HTMLElement): void;
+    groupRowClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    groupRowDoubleClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    selectGroupClick(row: IDictionary<any>, isSelected: boolean, event: Event, element?: HTMLElement): void;
+    setSearch(search: string): Promise<any>;
+    getAtomInstance<T>(key: keyof ITekGridAtoms): T;
+    getAtomName(key: keyof ITekGridAtoms): string;
+}