@zeedhi/common 1.120.2 → 1.122.0

package/dist/types/components/zd-form/interfaces.d.ts

@@ -0,0 +1,36 @@
+import { IEventParam } from '@zeedhi/core';
+import { EventDef, IComponentEvents, IComponentRender } from '../zd-component/interfaces';
+import { Form } from './form';
+export type IFormEvent = IEventParam<Form>;
+export interface IFormEvents extends IComponentEvents<IFormEvent> {
+    submit?: EventDef<IFormEvent>;
+}
+export interface IFormGrid {
+    cols?: string;
+    lg?: string;
+    md?: string;
+    sm?: string;
+    xl?: string;
+    xxl?: string;
+    offset?: string;
+    'offset-lg'?: string;
+    'offset-md'?: string;
+    'offset-sm'?: string;
+    'offset-xl'?: string;
+    'offset-xxl'?: string;
+}
+export interface IFormComponent extends IComponentRender {
+    grid?: IFormGrid;
+}
+export interface IForm extends IComponentRender {
+    align?: string;
+    justify?: string;
+    height?: number | string;
+    maxHeight?: number | string;
+    minHeight?: number | string;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    children?: IFormComponent[];
+    events?: IFormEvents;
+}

package/dist/types/components/zd-frame/frame.d.ts

@@ -0,0 +1,81 @@
+import { IDictionary } from '@zeedhi/core';
+import { ComponentRender } from '../zd-component/component-render';
+import { IFrame, IFrameEvents } from './interfaces';
+export declare class Frame extends ComponentRender implements IFrame {
+    loading: boolean;
+    local: boolean;
+    metadata: object;
+    override: object;
+    params: object;
+    overrideNamedProps: IDictionary;
+    path: string;
+    cache: boolean;
+    JSONCache: boolean | string;
+    events: IFrameEvents;
+    cacheDuration: number;
+    /**
+     * Defines the component height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    height: string | number;
+    /**
+     * Defines the component min height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    minHeight: string | number;
+    /**
+     * Defines the component max height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    maxHeight: string | number;
+    /**
+     * Defines the component width. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    width: string | number;
+    /**
+     * Defines the component min width. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    minWidth: string | number;
+    /**
+     * Defines the component max height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    maxWidth: string | number;
+    type: string;
+    private readonly headerName;
+    private static readonly cacheName;
+    protected resolveLoad?: (value: object) => void;
+    protected rejectLoad?: (reason?: any) => void;
+    constructor(props: IFrame);
+    onCreated(): void;
+    overrideNamedPropsFunc(metadata: object): any;
+    reload(): Promise<void>;
+    /**
+     * Triggered when frame is load.
+     * @param event
+     * @param element
+     */
+    afterLoad(event?: Event, element?: HTMLElement): void;
+    /**
+     * Deletes all frame cached requests
+     */
+    static deleteCache(): Promise<boolean>;
+    waitLoading(): Promise<object>;
+    protected notFoundError(e: unknown): void;
+    private getMetadata;
+    private requestPage;
+    /**
+     * Checks if cache response is valid (not expired yet)
+     * @param response
+     */
+    private isValid;
+    /**
+     * Puts the metadata in defined cache with defined url
+     * @param cache Cache object in which data will be stored
+     * @param url Metadata url
+     * @param metadata Metadata to be stored
+     */
+    private putCache;
+}

package/dist/types/components/zd-frame/interfaces.d.ts

@@ -0,0 +1,23 @@
+import { IDictionary, IEventParam } from '@zeedhi/core';
+import { EventDef, IComponentEvents, IComponentRender } from '../zd-component/interfaces';
+import { Frame } from './frame';
+export type IFrameEvent = IEventParam<Frame>;
+export interface IFrameEvents<T = IFrameEvent> extends IComponentEvents<T> {
+    onAfterLoad?: EventDef<T>;
+}
+export interface IFrame extends IComponentRender {
+    path: string;
+    local?: boolean;
+    override?: object;
+    overrideNamedProps?: IDictionary;
+    cache?: boolean;
+    JSONCache?: boolean | string;
+    cacheDuration?: number;
+    height?: number | string;
+    maxHeight?: number | string;
+    minHeight?: number | string;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    type?: string;
+}

package/dist/types/components/zd-frame-page/frame-page.d.ts

@@ -0,0 +1,14 @@
+import { Frame } from '../zd-frame/frame';
+import { IFramePage } from './interfaces';
+export declare class FramePage extends Frame implements IFramePage {
+    /**
+     * Set "NotFound" to the frame
+     */
+    notFoundRoute: string;
+    constructor(props: IFramePage);
+    /**
+     * Triggered before the component is destroyed.
+     */
+    onBeforeDestroy(): void;
+    protected notFoundError(e: unknown): void;
+}

package/dist/types/components/zd-frame-page/interfaces.d.ts

@@ -0,0 +1,4 @@
+import { IFrame } from '../zd-frame/interfaces';
+export interface IFramePage extends IFrame {
+    notFoundRoute?: string;
+}

package/dist/types/components/zd-grid/data-navigator.d.ts

@@ -0,0 +1,12 @@
+import { Direction, IDataNavigator, IGrid, IIterableTable } from './interfaces';
+export declare class DataNavigator implements IDataNavigator {
+    protected iterable: IGrid & IIterableTable;
+    constructor(iterable: IGrid & IIterableTable);
+    navigateDatasource(direction: Direction): void;
+    private navigateFirst;
+    private navigateLast;
+    private navigateInitial;
+    navigatePageDown(): void;
+    navigatePageUp(): void;
+    private navigateCurrentRow;
+}

package/dist/types/components/zd-grid/data-selector.d.ts

@@ -0,0 +1,25 @@
+import { IDictionary } from '@zeedhi/core';
+import { IDataSelector, IGrid } from './interfaces';
+export declare class DataSelector implements IDataSelector {
+    protected iterable: IGrid;
+    constructor(iterable: IGrid);
+    selectAll(isSelected: boolean): void;
+    toggleRow(row: IDictionary): void;
+    selectRow(row: IDictionary, select: boolean): void;
+    callDisableSelection(row: IDictionary<any>): boolean;
+    /**
+     * Dispatches select/unselect event
+     * @param row Grid row
+     * @param isSelected Row is selected
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    selectClick(row: IDictionary<any>, isSelected: boolean, event: Event, element: any): void;
+    /**
+     * Dispatches select/unselect all rows event
+     * @param isSelected Row is selected
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    selectAllClick(isSelected: boolean, event: Event, element: any): void;
+}

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

@@ -0,0 +1,47 @@
+import { IDictionary } from '@zeedhi/core';
+import { Column } from '../zd-iterable/column';
+import { IChildrenActionColumn, IGridColumn } from './interfaces';
+/**
+ * Base class for Grid column
+ */
+export declare class GridColumn extends Column implements IGridColumn {
+    children: IChildrenActionColumn[];
+    /**
+     * Creates a new Grid Column.
+     * @param props Grid column properties
+     */
+    constructor(props: IGridColumn);
+    /**
+     * Children props without grid system.
+     */
+    get childrenProps(): {
+        [key: string]: any;
+        allowDuplicate?: boolean | undefined;
+        autofocus?: boolean | undefined;
+        children?: import("..").IComponent[] | undefined;
+        componentId?: number | undefined;
+        cssClass?: string | undefined;
+        cssStyle?: string | IDictionary<any> | undefined;
+        events?: import("..").IComponentEvents<import("@zeedhi/core").IEventParam<any>> | undefined;
+        directives?: import("..").IComponentDirectives | undefined;
+        isVisible?: string | boolean | undefined;
+        dark?: boolean | undefined;
+        light?: boolean | undefined;
+        theme?: string | undefined;
+        keyMap?: import("@zeedhi/core").IKeyMap<import("@zeedhi/core").IEventParam<any>> | undefined;
+        name: string;
+        parent?: import("..").IComponentInstance | undefined;
+        tabStop?: boolean | undefined;
+        userProperties?: IDictionary<any> | undefined;
+        fillHeight?: boolean | undefined;
+    }[];
+    /**
+     * Get the Column without the conditions object
+     * @param component Column component
+     */
+    getColumnWithoutConditions(component: any): any;
+    /**
+     * checkOutValues
+     */
+    checkOutValues(component: any, row: IDictionary<any>, newRow: IDictionary<any>): void;
+}

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

@@ -0,0 +1,26 @@
+import { IDictionary } from '@zeedhi/core';
+import { GridColumn } from './grid-column';
+import { IGrid, IGridEvents } from './interfaces';
+export declare class GridEvents implements IGridEvents {
+    protected iterable: IGrid;
+    /**
+     * Flag to prevent row click
+     */
+    protected preventRowClick: boolean;
+    constructor(iterable: IGrid);
+    /**
+     * Dispatches row click event
+     * @param row Grid row
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    rowClick(row: IDictionary<any>, event: Event, element: any): void;
+    /**
+     * Dispatches cell click Event
+     * @param row Grid row
+     * @param column Grid column
+     * @param event DOM event
+     * @param element DOM Element
+     */
+    cellClick(row: IDictionary<any>, column: GridColumn, event: Event, element: any): void;
+}

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

@@ -0,0 +1,85 @@
+import { IDictionary, IEventParam } from '@zeedhi/core';
+import { IComponent, IComponentRender } from '../zd-component/interfaces';
+import { Iterable } from '../zd-iterable/iterable';
+import { GridColumn } from './grid-column';
+import { Direction, IGrid, IGridColumn, IGridEvents, IGridProps, VerticalDirection } from './interfaces';
+export declare class Grid extends Iterable<GridColumn> implements IGrid, IGridEvents {
+    private tableActionBuilder;
+    private iterableTable;
+    private dataSelector;
+    private gridEvents;
+    private dataNavigator;
+    private viewNavigator;
+    private keyMapMerger;
+    currentColumn: GridColumn | 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;
+    dragColumns: 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[];
+    resizeColumns: boolean;
+    showFooter: boolean;
+    showHeader: boolean;
+    showSelectAll: boolean;
+    width: string | number;
+    backgroundColor: string;
+    constructor(props: IGridProps);
+    getConditionalProps({ row, column }: {
+        row: IDictionary;
+        column: GridColumn;
+    }): Partial<IComponentRender>;
+    onMounted(element: HTMLElement): void;
+    onBeforeDestroy(): 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;
+    createColumn(column: IGridColumn): GridColumn;
+    rowClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    cellClick(row: IDictionary<any>, column: GridColumn, event: Event, element?: HTMLElement): void;
+    selectClick(row: IDictionary<any>, isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAllClick(isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAll(isSelected: boolean): void;
+    toggleRow(row: IDictionary): void;
+    selectRow(row: IDictionary, select: boolean): void;
+    callDisableSelection(row: IDictionary): boolean;
+    changeOrder(sortBy: {
+        key: string;
+        order: 'asc' | 'desc';
+    }[]): Promise<void>;
+    selectCell(row: IDictionary, column: GridColumn): void;
+    reapplyRowStyleConditions(row: IDictionary): IDictionary;
+    getRowStyleConditions(row: IDictionary): IDictionary;
+    deleteRows(): Promise<any[]>;
+    getActionComponent(actionComponent: IComponent, column: GridColumn, row: IDictionary, parentPath?: string): IComponent;
+    changeData(data?: IDictionary<any>[]): void;
+}

package/dist/types/components/zd-grid/index.d.ts

@@ -0,0 +1,11 @@
+export * from './data-selector';
+export * from './grid-column';
+export * from './grid-events';
+export * from './grid';
+export * from './interfaces';
+export * from './iterable-table';
+export * from './table-action-builder';
+export * from './keymap-navigation';
+export * from './keymap-merger';
+export * from './data-navigator';
+export * from './view-navigator';

package/dist/types/components/zd-grid/interfaces.d.ts

@@ -0,0 +1,148 @@
+import { IDictionary, IEventParam, IKeyMap } from '@zeedhi/core';
+import { EventDef, IComponent, IComponentRender } from '../zd-component/interfaces';
+import { IColumn, IIterable, IIterableEvents, IIterableProps } from '../zd-iterable/interfaces';
+import { Grid } from './grid';
+import { GridColumn } from './grid-column';
+export interface IGridColumn extends IColumn {
+    children?: IChildrenActionColumn[];
+}
+export interface IChildrenActionColumn extends IComponent {
+    conditions?: IDictionary;
+}
+export interface ITableActionBuilder {
+    getActionComponent(actionComponent: IComponent, column: GridColumn, row: IDictionary, parentPath?: string): IComponent;
+}
+export interface IIterableTable {
+    changeOrder(sortBy: {
+        key: string;
+        order: 'asc' | 'desc';
+    }[]): Promise<void>;
+    selectCell(row: IDictionary, column: GridColumn): void;
+    reapplyRowStyleConditions(row: IDictionary): IDictionary;
+    getRowStyleConditions(row: IDictionary): IDictionary;
+    deleteRows(): Promise<any[]>;
+}
+export interface IDataSelector {
+    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;
+}
+export interface IGridEvents {
+    rowClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    cellClick(row: IDictionary<any>, column: GridColumn, event: Event, element?: HTMLElement): void;
+}
+export type Direction = 'up' | 'down' | 'left' | 'right';
+export type VerticalDirection = 'up' | 'down';
+export interface IDataNavigator {
+    navigateDatasource(direction: VerticalDirection): void;
+    navigatePageUp(): void;
+    navigatePageDown(): void;
+}
+export interface IViewNavigator {
+    navigateLeft({ event }: IEventParam<any>): void;
+    navigateRight({ event }: IEventParam<any>): void;
+    navigateUp(): void;
+    navigateDown(): void;
+    setViewNavigate(viewNavigate: (direction: Direction, event?: Event) => void): void;
+}
+export interface IKeyMapConfig<T> {
+    getMap(instance: T): IKeyMap;
+}
+export interface IKeyMapMerger {
+    bind(element: HTMLElement): void;
+    unbind(): void;
+}
+export interface IGridEvent extends IEventParam<Grid> {
+    row: IDictionary;
+    column: IColumn;
+}
+export interface GridEventsProp<T = IGridEvent | IEventParam<any>> extends IIterableEvents<T> {
+    cellClick?: EventDef<T>;
+    rowClick?: EventDef<T>;
+    selected?: EventDef<T>;
+    selectedAll?: EventDef<T>;
+    unselected?: EventDef<T>;
+    unselectedAll?: EventDef<T>;
+}
+export interface IGridProps extends IIterableProps {
+    backgroundColor?: string;
+    cellSelection?: boolean;
+    dense?: boolean;
+    disableSelection?: (args: {
+        row: IDictionary<any>;
+        component: Grid;
+    }) => boolean;
+    dragColumns?: boolean;
+    errorSlot?: IComponentRender[];
+    events?: GridEventsProp;
+    fillHeight?: boolean;
+    footerSlot?: IComponentRender[];
+    headerBackground?: string;
+    headerCellTextColor?: string;
+    height?: number | string;
+    loadingText?: string;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+    noDataSlot?: IComponentRender[];
+    noDataText?: string;
+    noResultSlot?: IComponentRender[];
+    noResultsText?: string;
+    resizeColumns?: boolean;
+    rowStyleConditions?: (row: IDictionary) => IDictionary;
+    selectable?: boolean;
+    selectAllPages?: boolean;
+    showFooter?: boolean;
+    showHeader?: boolean;
+    showSelectAll?: boolean;
+    toolbarSlot?: IComponentRender[];
+    width?: number | string;
+}
+export interface IGrid<T = GridColumn> extends IIterable<T>, IIterableTable, IDataSelector, IDataNavigator, IViewNavigator, ITableActionBuilder {
+    backgroundColor: string;
+    cellSelection: boolean;
+    currentColumn: GridColumn | null;
+    dense: boolean;
+    disableSelection?: (args: {
+        row: IDictionary<any>;
+        component: IGrid;
+    }) => boolean;
+    dragColumns: boolean;
+    errorSlot: IComponentRender[];
+    events: GridEventsProp;
+    footerSlot: IComponentRender[];
+    headerBackground: string;
+    headerCellTextColor: string;
+    height: number | string;
+    loadingText: string;
+    maxHeight: number | string;
+    maxWidth: number | string;
+    minHeight: number | string;
+    minWidth: number | string;
+    noDataSlot: IComponentRender[];
+    noDataText: string;
+    noResultSlot: IComponentRender[];
+    noResultsText: string;
+    resizeColumns: boolean;
+    rowStyleConditions?: (row: IDictionary) => IDictionary;
+    selectable: boolean;
+    selectAllPages: boolean;
+    selectedRows: IDictionary[];
+    selectionState: {
+        allSelected: boolean;
+        except: IDictionary<any>[];
+    };
+    showFooter: boolean;
+    showHeader: boolean;
+    showSelectAll: boolean;
+    toolbarSlot: IComponentRender[];
+    width: number | string;
+    getConditionalProps({ row, column }: {
+        row: IDictionary;
+        column: T;
+    }): Partial<IComponentRender>;
+}

package/dist/types/components/zd-grid/iterable-table.d.ts

@@ -0,0 +1,28 @@
+import { IDictionary } from '@zeedhi/core';
+import { GridColumn } from './grid-column';
+import { IGrid, IIterableTable } from './interfaces';
+export declare class IterableTable implements IIterableTable {
+    protected iterable: IGrid;
+    /**
+     * Available order types
+     * @public
+     */
+    orderTypes: {
+        asc: 'asc';
+        desc: 'desc';
+    };
+    constructor(iterable: IGrid);
+    /**
+     * Changes column order
+     * @async
+     */
+    changeOrder(sortBy: {
+        key: string;
+        order: 'asc' | 'desc';
+    }[]): Promise<void>;
+    selectCell(row: IDictionary, column: GridColumn): void;
+    protected rowStyleConditions: Map<any, any>;
+    reapplyRowStyleConditions(row: IDictionary<any>): IDictionary<any>;
+    getRowStyleConditions(row: IDictionary): IDictionary;
+    deleteRows(): Promise<any[]>;
+}

package/dist/types/components/zd-grid/keymap-merger.d.ts

@@ -0,0 +1,26 @@
+import { Component } from '../zd-component/component';
+import { IKeyMapConfig, IKeyMapMerger } from './interfaces';
+type ClassType<T> = {
+    new (): T;
+};
+type ConfigClassType = ClassType<IKeyMapConfig<Component>>;
+/**
+ * This class' purpose is to allow merging multiple keyMap configurations
+ * into the same component instance and element
+ *
+ * Also allows users to overwrite the default keyMap by defining their own
+ * keymaps via component props
+ */
+export declare class KeyMapMerger implements IKeyMapMerger {
+    private instance;
+    private configs;
+    private map;
+    constructor(instance: Component, configs: ConfigClassType[]);
+    /**
+     * Filters keyMap to allow user to overwrite the default keyMapping
+     */
+    private filterKeyMapping;
+    bind(element: HTMLElement): void;
+    unbind(): void;
+}
+export {};

package/dist/types/components/zd-grid/keymap-navigation.d.ts

@@ -0,0 +1,6 @@
+import { IKeyMap } from '@zeedhi/core';
+import { Component } from '../zd-component/component';
+import { IDataNavigator, IKeyMapConfig, IViewNavigator } from './interfaces';
+export declare class KeyMapNavigation implements IKeyMapConfig<IViewNavigator & IDataNavigator> {
+    getMap(instance: Component & IViewNavigator & IDataNavigator): IKeyMap;
+}

package/dist/types/components/zd-grid/table-action-builder.d.ts

@@ -0,0 +1,19 @@
+import { IDictionary } from '@zeedhi/core';
+import { Component } from '../zd-component/component';
+import { IComponent } from '../zd-component/interfaces';
+import { Iterable } from '../zd-iterable/iterable';
+import { GridColumn } from './grid-column';
+import { ITableActionBuilder } from './interfaces';
+export declare class TableActionBuilder implements ITableActionBuilder {
+    protected iterable: Iterable;
+    constructor(iterable: Iterable);
+    getActionComponent(actionComponent: IComponent, column: GridColumn, row: IDictionary, parentPath?: string): IComponent;
+    private setGridRowsInEvents;
+    private filterObject;
+    private deleteAccessorProps;
+    protected updateActionInstance(instanceName: string, newComponent: IComponent): Component<IComponent>;
+    protected getActionProps(actionComponent: IComponent, column: GridColumn, row: IDictionary, parentPath: string): {
+        props: IComponent;
+        instance: Component<IComponent> | null;
+    };
+}

package/dist/types/components/zd-grid/view-navigator.d.ts

@@ -0,0 +1,10 @@
+import { IEventParam } from '@zeedhi/core';
+import { Direction, IViewNavigator } from './interfaces';
+export declare class ViewNavigator implements IViewNavigator {
+    protected viewNavigate: ((direction: Direction, event?: Event) => void) | null;
+    setViewNavigate(viewNavigate: (direction: Direction, event?: Event) => void): void;
+    navigateLeft({ event }: IEventParam<any>): void;
+    navigateRight({ event }: IEventParam<any>): void;
+    navigateUp(): void;
+    navigateDown(): void;
+}

package/dist/types/components/zd-grid-editable/data-editor-with-add.d.ts

@@ -0,0 +1,35 @@
+import { IDictionary } from '@zeedhi/core';
+import { Input } from '../zd-input/input';
+import { DataEditor } from './data-editor';
+import { IDataEditorWithAdd, IGridColumnEditable, IGridEditable } from './interfaces';
+export declare class DataEditorWithAdd extends DataEditor implements IDataEditorWithAdd {
+    private NEW_ROW_IDENTIFIER;
+    /**
+     * Rows with newRowIdentifier
+     * @private
+     */
+    private addedRows;
+    constructor(grid: IGridEditable);
+    addCancelColumn(): void;
+    getCancelColumnProps(): IGridColumnEditable;
+    createGridController(): void;
+    isAdded(row: IDictionary): boolean;
+    cancelAddedRow(key: string | number): Promise<any>;
+    cancelAddedRows(): Promise<void>;
+    getAddedRows(): IDictionary<any>[];
+    addNewRow(row: IDictionary, position?: 'end' | 'start'): Promise<void>;
+    changeEditableComponent(column: IGridColumnEditable, row: IDictionary<any>, value: any, component?: Input): void;
+    private addDataRow;
+    /**
+     * Saves all edited rows if they are valid
+     * @param revalidate Defines if the fields should be revalidated
+     * @throws Will throw when it finds an invalid row
+     */
+    saveEditedRows(revalidate?: boolean): Promise<void[]>;
+    /**
+     * Cancels all edited rows and enable grid components
+     */
+    cancelEditedRows(): Promise<void>;
+    protected omitInternals(editedRow: IDictionary): any;
+    reapplyCanEditRow(row: IDictionary<any>): void;
+}