@orangelogic/design-system 2.19.0-pr77202.21

package/library/packages/atoms/src/components/table/tabulator-tables/core/tools/InternalEventBus.d.ts

@@ -0,0 +1,22 @@
+import { EventSubscriber, IInternalEventBus, InternalEventBusEventCallback } from '../../../../../../../types/src/table';
+
+export default class InternalEventBus implements IInternalEventBus {
+    events: Record<string, EventSubscriber[]>;
+    subscriptionNotifiers: Record<string, InternalEventBusEventCallback[]>;
+    dispatch: (key: string, ...args: any[]) => void;
+    chain: (key: string, args: any[] | any, initialValue: any, fallback?: any) => any;
+    confirm: (key: string, args: any[] | any) => boolean;
+    debug: boolean | string[] | undefined;
+    constructor(debug?: boolean | string[]);
+    subscriptionChange(key: string, callback: InternalEventBusEventCallback): void;
+    subscribe(key: string, callback: (...args: any[]) => any, priority?: number): void;
+    unsubscribe(key: string, callback?: (...args: any[]) => any): void;
+    subscribed(key: string): boolean;
+    _chain(key: string, args: any[] | any, initialValue: any, fallback?: any): any;
+    _confirm(key: string, args: any[] | any): boolean;
+    _notifySubscriptionChange(key: string, subscribed: boolean): void;
+    _dispatch(key: string, ...args: any[]): void;
+    _debugDispatch(key: string, ...args: any[]): any;
+    _debugChain(key: string, args: any[] | any, initialValue: any, fallback?: any): any;
+    _debugConfirm(key: string, args: any[] | any): boolean;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/core/tools/ModuleBinder.d.ts

@@ -0,0 +1,43 @@
+import { IModuleBinder } from '../../../../../../../types/src/table';
+import { default as Ajax } from '../../modules/Ajax/Ajax';
+import { default as Clipboard } from '../../modules/Clipboard/Clipboard';
+import { default as Comms } from '../../modules/Comms/Comms';
+import { default as Edit } from '../../modules/Edit/Edit';
+import { default as History } from '../../modules/History/History';
+import { default as Layout } from '../../modules/Layout/Layout';
+import { default as Localize } from '../../modules/Localize/Localize';
+import { default as MoveRow } from '../../modules/MoveRows/MoveRows';
+import { default as SelectRow } from '../../modules/SelectRow/SelectRow';
+import { default as Module } from '../Module';
+import { default as TableRegistry } from './TableRegistry';
+
+type Modules = {
+    ajax?: Ajax;
+    clipboard?: Clipboard;
+    comms?: Comms;
+    edit?: Edit;
+    history?: History;
+    layout?: Layout;
+    localize?: Localize;
+    moveRow?: MoveRow;
+    selectRow?: SelectRow;
+} & Record<string, Module>;
+export default class ModuleBinder extends TableRegistry implements IModuleBinder {
+    static readonly moduleBindings: Record<string, typeof Module>;
+    static readonly moduleExtensions: Record<string, Record<string, Record<string, any>>>;
+    static modulesRegistered: boolean;
+    static readonly defaultModules = false;
+    modules: Modules;
+    modulesCore: Module[];
+    modulesRegular: Module[];
+    constructor();
+    static initializeModuleBinder(defaultModules?: Record<string, typeof Module> | false): void;
+    static _extendModule(name: string, property: string, values: Record<string, any>): void;
+    static _registerModules(modules: Record<string, typeof Module>, core?: boolean): void;
+    static _registerModule(modules: Array<typeof Module> | typeof Module): void;
+    static _registerModuleBinding(mod: typeof Module): void;
+    static _registerModuleExtensions(mod: typeof Module): void;
+    static _extendModuleFromQueue(mod: typeof Module): void;
+    _bindModules(): void;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/core/tools/OptionsList.d.ts

@@ -0,0 +1,10 @@
+import { IOptionsList, ITabulator } from '../../../../../../../types/src/table';
+
+export default class OptionsList implements IOptionsList {
+    table: ITabulator;
+    msgType: string;
+    registeredDefaults: Record<string, any>;
+    constructor(table: ITabulator, msgType: string, defaults?: Record<string, any>);
+    register(option: string, value: any): void;
+    generate(defaultOptions: Record<string, any>, userOptions?: Record<string, any>): Record<string, any>;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/core/tools/Popup.d.ts

@@ -0,0 +1,49 @@
+import { IPopup, ITabulator } from '../../../../../../../types/src/table';
+import { default as CoreFeature } from '../CoreFeature';
+
+export default class Popup extends CoreFeature implements IPopup {
+    element: HTMLElement;
+    container: HTMLElement;
+    parent: IPopup | null;
+    reversedX: boolean;
+    childPopup: IPopup | null;
+    blurable: boolean;
+    blurCallback: (() => void) | null;
+    blurEventsBound: boolean;
+    renderedCallback: (() => void) | null;
+    visible: boolean;
+    hideable: boolean;
+    blurEvent: () => void;
+    escEvent: (e: KeyboardEvent) => void;
+    destroyBinding: () => void;
+    destroyed: boolean;
+    constructor(table: ITabulator, element: HTMLElement, parent?: IPopup | null);
+    tableDestroyed(): void;
+    _lookupContainer(): HTMLElement;
+    _checkContainerIsParent(container: HTMLElement, element?: HTMLElement | ParentNode): boolean;
+    renderCallback(callback: () => void): void;
+    containerEventCoords(e: MouseEvent | TouchEvent): {
+        x: number;
+        y: number;
+    };
+    elementPositionCoords(element: HTMLElement, position?: 'right' | 'bottom' | 'left' | 'top' | 'center'): {
+        offset: {
+            left: number;
+            top: number;
+        };
+        x: number;
+        y: number;
+    };
+    show(origin: HTMLElement | MouseEvent | TouchEvent | number, position?: 'right' | 'bottom' | 'left' | 'top' | 'center' | number): this;
+    _fitToScreen(x: number, y: number, parentEl: HTMLElement | undefined, parentOffset: {
+        left: number;
+        top: number;
+    } | undefined, position: 'right' | 'bottom' | 'left' | 'top' | 'center' | undefined): void;
+    isVisible(): boolean;
+    hideOnBlur(callback: () => void): this;
+    _escapeCheck(e: KeyboardEvent): void;
+    blockHide(): void;
+    restoreHide(): void;
+    hide(silent?: boolean): this;
+    child(element: HTMLElement): IPopup;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/core/tools/TableRegistry.d.ts

@@ -0,0 +1,12 @@
+import { default as Tabulator } from '../Tabulator';
+
+export default class TableRegistry {
+    static readonly registry: {
+        deregister: (table: Tabulator) => void;
+        lookupTable: (query: any, silent?: boolean) => Tabulator[];
+        matchElement: (element: any) => Tabulator | undefined;
+        register: (table: Tabulator) => void;
+        tables: Tabulator[];
+    };
+    static findTable(query: any): Tabulator[] | false;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/index.d.ts

@@ -0,0 +1,14 @@
+export * from './core/modules/optional';
+export { default as Tabulator } from './core/Tabulator';
+export { default as TabulatorFull } from './core/TabulatorFull';
+export { default as CellComponent } from './core/cell/CellComponent';
+export { default as ColumnComponent } from './core/column/ColumnComponent';
+export { default as RowComponent } from './core/row/RowComponent';
+export { default as GroupComponent } from './modules/GroupRows/GroupComponent';
+export { default as CalcComponent } from './modules/ColumnCalcs/CalcComponent';
+export { default as RangeComponent } from './modules/SelectRange/RangeComponent';
+export { default as SheetComponent } from './modules/Spreadsheet/SheetComponent';
+export { default as PseudoRow } from './core/row/PseudoRow';
+export { default as Row } from './core/row/Row';
+export { default as Module } from './core/Module';
+export { default as Renderer } from './core/rendering/Renderer';

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Accessibility/Accessibility.d.ts

@@ -0,0 +1,7 @@
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+
+export default class Accessibility extends Module {
+    static moduleName: string;
+    constructor(table: Tabulator);
+}

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Accessor/Accessor.d.ts

@@ -0,0 +1,18 @@
+import { default as Column } from '../../core/column/Column';
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+import { default as Tabulator } from '../../core/Tabulator';
+import { CustomAccessor } from '../../core/types';
+
+type AccessorType = '' | 'data' | 'download' | 'clipboard' | 'print' | 'htmlOutput';
+export default class Accessor extends Module {
+    static moduleName: string;
+    static accessors: Record<string, CustomAccessor>;
+    allowedTypes: AccessorType[];
+    constructor(table: Tabulator);
+    initialize(): void;
+    initializeColumn(column: Column): void;
+    lookupAccessor(value: string | CustomAccessor): CustomAccessor | false;
+    transformRow(row: Row, type: AccessorType): Record<string, any>;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Accessor/defaults/accessors.d.ts

@@ -0,0 +1,4 @@
+import { CustomAccessor } from '../../../core/types';
+
+declare const accessors: Record<string, CustomAccessor>;
+export default accessors;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Ajax/Ajax.d.ts

@@ -0,0 +1,41 @@
+import { AjaxConfig, AjaxContentType, HttpMethod, ITabulator } from '../../../../../../../types/src/table';
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+
+type LoaderPromise = (this: {
+    contentTypeFormatters: Record<string, AjaxContentType>;
+    table: ITabulator;
+    urlGenerator: URLGenerator | false;
+}, url: string, config: any, params: Record<string, unknown>) => Promise<any>;
+type URLGenerator = (url: string, config: any, params: Record<string, unknown>) => string;
+export default class Ajax extends Module {
+    static moduleName: string;
+    static defaultConfig: AjaxConfig;
+    static defaultURLGenerator: URLGenerator;
+    static contentTypeFormatters: Record<string, AjaxContentType>;
+    config: AjaxConfig;
+    url: string;
+    urlGenerator: URLGenerator | false;
+    params: Record<string, unknown> | false;
+    loaderPromise: LoaderPromise | false;
+    contentTypeFormatters: Record<string, AjaxContentType>;
+    static defaultLoaderPromise: LoaderPromise;
+    constructor(table: Tabulator);
+    initialize(): void;
+    requestParams(data: any, config: any, silent: boolean, params: Record<string, unknown>): Record<string, unknown>;
+    requestDataCheck(data: any): boolean;
+    requestData(url: string | any, params: Record<string, unknown>, config: any, silent: boolean, previousData: any): Promise<any> | any;
+    setDefaultConfig(config?: HttpMethod | AjaxConfig | undefined): void;
+    generateConfig(config?: HttpMethod | AjaxConfig | undefined): RequestInit;
+    setUrl(url: string): void;
+    getUrl(): string;
+    /**
+     * Send an AJAX request to the specified URL with the given parameters and configuration.
+     * @param url - The URL to send the request to.
+     * @param params - The parameters to send with the request.
+     * @param config - The configuration to send with the request.
+     * @returns A promise that resolves to the data from the request.
+     */
+    sendRequest(url: string, params: Record<string, unknown>, config: RequestInit): Promise<any>;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Ajax/defaults/config.d.ts

@@ -0,0 +1,4 @@
+import { AjaxConfig } from '../../../core/types';
+
+declare const config: AjaxConfig;
+export default config;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Ajax/defaults/contentTypeFormatters.d.ts

@@ -0,0 +1,4 @@
+import { AjaxContentType } from '../../../core/types';
+
+declare const contentTypeFormatters: Record<string, AjaxContentType>;
+export default contentTypeFormatters;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Ajax/defaults/urlGenerator.d.ts

@@ -0,0 +1,3 @@
+type URLGenerator = (url: string, config: RequestInit, params: Record<string, unknown>) => string;
+declare const urlGenerator: URLGenerator;
+export default urlGenerator;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Clipboard/Clipboard.d.ts

@@ -0,0 +1,35 @@
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+import { PasteParser, RowRangeLookup } from '../../core/types';
+
+type PasteAction = (this: Clipboard, data: Array<Record<string, any>>) => any;
+type ClipboardMode = boolean | 'copy' | 'paste';
+export default class Clipboard extends Module {
+    static readonly moduleName = "clipboard";
+    static readonly moduleExtensions: {
+        keybindings: {
+            actions: Record<string, (this: import('../Keybindings/Keybindings').default, e: KeyboardEvent) => void>;
+            bindings: Record<string, string | string[]>;
+        };
+    };
+    static readonly pasteActions: Record<string, PasteAction>;
+    static readonly pasteParsers: Record<string, PasteParser>;
+    mode: ClipboardMode;
+    pasteParser: PasteParser;
+    pasteAction: PasteAction;
+    customSelection: string | false;
+    rowRange: RowRangeLookup;
+    blocked: boolean;
+    constructor(table: Tabulator);
+    initialize(): void;
+    reset(): void;
+    generatePlainContent(list: any[]): string;
+    copy(range?: RowRangeLookup, internal?: boolean): void;
+    setPasteAction(action?: string | PasteAction): void;
+    setPasteParser(parser?: string | PasteParser): void;
+    paste(e: ClipboardEvent): void;
+    mutateData(data: Array<Record<string, any>> | Record<string, any>): Array<Record<string, any>>;
+    checkPasteOrigin(e: ClipboardEvent): boolean;
+    getPasteData(e: ClipboardEvent): string | undefined;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Clipboard/defaults/pasteActions.d.ts

@@ -0,0 +1,5 @@
+import { default as Clipboard } from '../Clipboard';
+
+type PasteAction = (this: Clipboard, data: Array<Record<string, any>>) => any;
+declare const pasteActions: Record<string, PasteAction>;
+export default pasteActions;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Clipboard/defaults/pasteParsers.d.ts

@@ -0,0 +1,4 @@
+import { PasteParser } from '../../../../../../../../types/src/table';
+
+declare const pasteParsers: Record<string, PasteParser>;
+export default pasteParsers;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Clipboard/extensions/extensions.d.ts

@@ -0,0 +1,7 @@
+declare const extensions: {
+    keybindings: {
+        actions: Record<string, (this: import('../../..').KeybindingsModule, e: KeyboardEvent) => void>;
+        bindings: Record<string, string | string[]>;
+    };
+};
+export default extensions;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Clipboard/extensions/keybindings/actions.d.ts

@@ -0,0 +1,5 @@
+import { default as Keybindings } from '../../../Keybindings/Keybindings';
+
+type KeybindingAction = (this: Keybindings, e: KeyboardEvent) => void;
+declare const actions: Record<string, KeybindingAction>;
+export default actions;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Clipboard/extensions/keybindings/bindings.d.ts

@@ -0,0 +1,3 @@
+type KeybindingBinding = string | string[];
+declare const bindings: Record<string, KeybindingBinding>;
+export default bindings;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/ColumnCalcs/CalcComponent.d.ts

@@ -0,0 +1,13 @@
+import { ICalcComponent, ICellComponent, IColumnComponent, ITabulator } from '../../../../../../../types/src/table';
+import { default as Row } from '../../core/row/Row';
+
+export default class CalcComponent implements ICalcComponent {
+    _row: Row;
+    constructor(row: Row);
+    getData(transform?: string): Record<string, any>;
+    getElement(): HTMLElement | false;
+    getTable(): ITabulator;
+    getCells(): ICellComponent[];
+    getCell(column: IColumnComponent): ICellComponent | false;
+    _getSelf(): Row;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/modules/ColumnCalcs/ColumnCalcs.d.ts

@@ -0,0 +1,67 @@
+import { IRow } from '../../../../../../../types/src/table';
+import { default as Cell } from '../../core/cell/Cell';
+import { default as Column } from '../../core/column/Column';
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+import { ColumnCalcParams, ITabulator } from '../../core/types';
+
+type CalcFunction = (values: any[], data: Array<Record<string, any>>, params: ColumnCalcParams) => any;
+export default class ColumnCalcs extends Module {
+    static moduleName: string;
+    static calculations: Record<string, CalcFunction>;
+    topCalcs: Column[];
+    botCalcs: Column[];
+    genColumn: Column | false;
+    topElement: HTMLElement;
+    botElement: HTMLElement;
+    topRow: IRow | false;
+    botRow: IRow | false;
+    topInitialized: boolean;
+    botInitialized: boolean;
+    blocked: boolean;
+    recalcAfterBlock: boolean;
+    constructor(table: ITabulator);
+    createElement(): HTMLElement;
+    initialize(): void;
+    resizeHolderWidth(): void;
+    tableRedraw(force?: boolean): Promise<void>;
+    blockRedraw(): void;
+    restoreRedraw(): void;
+    /**
+     * Table Functions
+     */
+    userRecalc(): Promise<void>;
+    /**
+     * Internal Logic
+     */
+    blockCheck(): boolean;
+    visibleRows(viewable: any, rows: IRow[]): IRow[];
+    rowsUpdated(row?: IRow): void;
+    recalcActiveRowsRefresh(): Promise<void>;
+    recalcActiveRows(): Promise<void>;
+    cellValueChanged(cell: Cell): void;
+    initializeColumnCheck(column: Column): void;
+    initializeColumn(column: Column): void;
+    registerColumnField(): void;
+    removeCalcs(): void;
+    reinitializeCalcs(): void;
+    initializeTopRow(): void;
+    initializeBottomRow(): void;
+    scrollHorizontal(left: number): void;
+    recalc(rows: IRow[]): Promise<void>;
+    recalcRowGroup(row: IRow): void;
+    recalcAll(): Promise<void>;
+    recalcGroup(group: any): void;
+    generateTopRow(rows: Row[]): IRow;
+    generateBottomRow(rows: Row[]): IRow;
+    rowsToData(rows: IRow[]): Array<Record<string, any>>;
+    generateRow(pos: 'top' | 'bottom', data: Array<Record<string, any>>): IRow;
+    generateRowData(pos: 'top' | 'bottom', data: Array<Record<string, any>>): Record<string, any>;
+    hasTopCalcs(): boolean;
+    hasBottomCalcs(): boolean;
+    redraw(): void;
+    getResults(): Record<string, any>;
+    getGroupResults(group: any): Record<string, any>;
+    adjustForScrollbar(width: number): void;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/ColumnCalcs/defaults/calculations.d.ts

@@ -0,0 +1,5 @@
+import { ColumnCalcParams } from '../../../core/types';
+
+type CalcFunction = (values: any[], data: Array<Record<string, any>>, calcParams: ColumnCalcParams) => any;
+declare const calculations: Record<string, CalcFunction>;
+export default calculations;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Comms/Comms.d.ts

@@ -0,0 +1,12 @@
+import { TableSelector } from '../../../../../../../types/src/table';
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+
+export default class Comms extends Module {
+    static readonly moduleName = "comms";
+    constructor(table: Tabulator);
+    initialize(): void;
+    getConnections(selectors: TableSelector): Tabulator[];
+    send(selectors: TableSelector, module: string, action: string, data?: any): void;
+    receive(table: HTMLElement, module: string, action: string, data?: any): any;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/modules/DataTree/DataTree.d.ts

@@ -0,0 +1,59 @@
+import { default as CxIconButton } from '../../../../icon-button/icon-button.ts';
+import { IRow } from '../../../../../../../types/src/table';
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+import { default as RowComponent } from '../../core/row/RowComponent';
+import { default as Tabulator } from '../../core/Tabulator';
+
+type StartOpenFunction = (row: RowComponent, index: number) => boolean;
+export default class DataTree extends Module {
+    static readonly moduleName = "dataTree";
+    indent: number;
+    field: string;
+    loadingField: string;
+    hasMoreField: string;
+    collapseEl: HTMLElement | null;
+    expandEl: CxIconButton | HTMLElement | null;
+    branchEl: HTMLElement | null;
+    elementField: string | false;
+    startOpen: StartOpenFunction;
+    constructor(table: Tabulator);
+    initialize(): void;
+    tableRedrawing(force?: boolean): void;
+    initializeElementField(): void;
+    getRowChildren(row: Row): RowComponent[];
+    columnMoving(): IRow[];
+    rowDataChanged(row: Row, visible: boolean, updatedData: Record<string, any>): void;
+    cellValueChanged(cell: any): void;
+    initializeRow(row: Row): void;
+    reinitializeRowChildren(row: IRow): void;
+    layoutRow(row: Row): void;
+    generateControlElement(row: Row, el?: HTMLElement | null): void;
+    getRows(rows: IRow[]): IRow[];
+    getChildren(row: Row, allChildren: boolean, sortOnly: boolean): Row[];
+    generateChildren(row: IRow): IRow[];
+    generateLoadMoreButton({ childLevel, parentRow, }: {
+        childLevel: number;
+        parentRow: IRow;
+    }): IRow;
+    generateLoadingRow({ childLevel, parentRow, }: {
+        childLevel: number;
+        parentRow: IRow;
+    }): IRow;
+    expandRow(row: Row, _silent?: boolean): void;
+    loadRowChildren(row: Row): Promise<void>;
+    collapseRow(row: Row): void;
+    toggleRow(row: Row): void;
+    isRowExpanded(row: Row): boolean;
+    getTreeParent(row: Row): RowComponent | false;
+    getTreeParentRoot(row: Row): Row;
+    getFilteredTreeChildren(row: Row): Row[];
+    rowDeleting(row: Row): void;
+    rowDelete(row: Row): void;
+    addTreeChildRow(row: Row, data: Record<string, any> | string, top?: boolean, index?: any): void;
+    findChildIndex(subject: any, parent: Row): number | false;
+    getTreeChildren(row: IRow, component: boolean, recurse: boolean): IRow[] | RowComponent[];
+    getChildField(): string;
+    redrawNeeded(data: Record<string, any>): boolean;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/Download.d.ts

@@ -0,0 +1,19 @@
+import { ITabulator } from '../../../../../../../types/src/table';
+import { default as Module } from '../../core/Module';
+import { DownloadOptions, RowRangeLookup } from '../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: any, mimeType: string) => void) => void;
+type InterceptCallback = ((data: any) => void) | boolean;
+export default class Download extends Module {
+    static moduleName: string;
+    static downloaders: Record<string, DownloadFunction>;
+    constructor(table: ITabulator);
+    initialize(): void;
+    deprecatedOptionsCheck(): void;
+    downloadToTab(type: string | DownloadFunction, filename?: string, options?: DownloadOptions, active?: RowRangeLookup): void;
+    download(type: string | DownloadFunction, filename?: string, options?: DownloadOptions, range?: RowRangeLookup, interceptCallback?: InterceptCallback): void;
+    generateExportList(range?: RowRangeLookup): any[];
+    triggerDownload(data: any, mime: string, type: string | DownloadFunction, filename?: string, newTab?: boolean): void;
+    commsReceived(table: HTMLElement, action: string, data: any): void;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders/csv.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: string, mimeType: string) => void) => void;
+declare const csv: DownloadFunction;
+export default csv;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders/html.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: string, mimeType: string) => void) => void;
+declare const html: DownloadFunction;
+export default html;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders/json.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: string, mimeType: string) => void) => void;
+declare const json: DownloadFunction;
+export default json;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders/jsonLines.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: string, mimeType: string) => void) => void;
+declare const jsonLines: DownloadFunction;
+export default jsonLines;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders/pdf.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: ArrayBuffer, mimeType: string) => void) => void;
+declare const pdf: DownloadFunction;
+export default pdf;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders/xlsx.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: ArrayBuffer | any, mimeType: string) => void) => void;
+declare const xlsx: DownloadFunction;
+export default xlsx;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Download/defaults/downloaders.d.ts

@@ -0,0 +1,6 @@
+import { ITabulator } from '../../../../../../../../types/src/table';
+import { DownloadOptions } from '../../../core/types';
+
+type DownloadFunction = (this: ITabulator, list: any[], options: DownloadOptions, setFileContents: (data: any, mimeType: string) => void) => void;
+declare const downloaders: Record<string, DownloadFunction>;
+export default downloaders;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Edit/Edit.d.ts

@@ -0,0 +1,57 @@
+import { ICellComponent } from '../../../../../../../types/src/table';
+import { default as Cell } from '../../core/cell/Cell';
+import { default as CellComponent } from '../../core/cell/CellComponent';
+import { default as Column } from '../../core/column/Column';
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+import { Editor, EditorParams } from '../../core/types';
+
+type EditorFunction = (this: Edit, cell: CellComponent, onRendered: (callback: () => void) => void, success: (value: any) => boolean, cancel: () => void, editorParams: EditorParams) => HTMLElement | false;
+export default class Edit extends Module {
+    static readonly moduleName = "edit";
+    static readonly editors: Record<string, EditorFunction>;
+    currentCell: Cell | false;
+    mouseClick: boolean;
+    recursionBlock: boolean;
+    invalidEdit: boolean;
+    editedCells: Cell[];
+    convertEmptyValues: boolean;
+    editors: Record<string, EditorFunction>;
+    constructor(table: any);
+    initialize(): void;
+    pasteBlocker(): boolean;
+    keybindingNavigateNext(e: any): void;
+    cellIsEdited(cell: CellComponent): boolean;
+    cellCancelEdit(cell: CellComponent): void;
+    updateCellClass(cell: Cell): void;
+    clearCellEdited(cells?: CellComponent | CellComponent[]): void;
+    navigatePrev(cell?: Cell | false, e?: Event): boolean;
+    navigateNext(cell?: Cell | false, e?: Event): boolean;
+    navigateLeft(cell?: Cell | false, e?: Event): boolean;
+    navigateRight(cell?: Cell | false, e?: Event): boolean;
+    navigateUp(cell?: Cell | false, e?: Event): boolean;
+    navigateDown(cell?: Cell | false, e?: Event): boolean;
+    findNextEditableCell(row: Row, index: number): Cell | false;
+    findPrevEditableCell(row: Row, index: number): Cell | false;
+    initializeColumnCheck(column: Column): void;
+    columnDeleteCheck(column: Column): void;
+    rowDeleteCheck(row: Row): void;
+    rowEditableCheck(row: Row): void;
+    initializeColumn(column: Column): void;
+    lookupEditor(editor: Editor | undefined, column: Column): EditorFunction | false;
+    getCurrentCell(): ICellComponent | false;
+    clearEditor(cancel: boolean): void;
+    cancelEdit(): void;
+    bindEditor(cell: Cell): void;
+    focusCellNoEvent(cell: Cell, block?: boolean): void;
+    editCell(cell: ICellComponent | null, forceEdit?: boolean): void;
+    focusScrollAdjust(cell: Cell): void;
+    allowEdit(cell: Cell): boolean;
+    edit(cell: Cell, e: Event | false, forceEdit?: boolean): boolean;
+    emptyValueCheck(value: unknown): boolean;
+    transformEmptyValues(value: any, cell: Cell): any;
+    blur(element: HTMLElement | null): void;
+    getEditedCells(): CellComponent[];
+    clearEdited(cell: Cell): void;
+}
+export {};