@orangelogic/design-system 2.19.0-ci.5

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

@@ -0,0 +1,50 @@
+import { default as adaptable } from './formatters/adaptable';
+import { default as array } from './formatters/array';
+import { default as buttonCross } from './formatters/buttonCross';
+import { default as buttonTick } from './formatters/buttonTick';
+import { default as color } from './formatters/color';
+import { default as datetime } from './formatters/datetime';
+import { default as datetimediff } from './formatters/datetimediff';
+import { default as handle } from './formatters/handle';
+import { default as html } from './formatters/html';
+import { default as image } from './formatters/image';
+import { default as json } from './formatters/json';
+import { default as link } from './formatters/link';
+import { default as lookup } from './formatters/lookup';
+import { default as money } from './formatters/money';
+import { default as plaintext } from './formatters/plaintext';
+import { default as progress } from './formatters/progress';
+import { default as rownum } from './formatters/rownum';
+import { default as star } from './formatters/star';
+import { default as tag } from './formatters/tag';
+import { default as textarea } from './formatters/textarea';
+import { default as tickCross } from './formatters/tickCross';
+import { default as toggle } from './formatters/toggle';
+import { default as traffic } from './formatters/traffic';
+
+declare const _default: {
+    adaptable: typeof adaptable;
+    array: typeof array;
+    buttonCross: typeof buttonCross;
+    buttonTick: typeof buttonTick;
+    color: typeof color;
+    datetime: typeof datetime;
+    datetimediff: typeof datetimediff;
+    handle: typeof handle;
+    html: typeof html;
+    image: typeof image;
+    json: typeof json;
+    link: typeof link;
+    lookup: typeof lookup;
+    money: typeof money;
+    plaintext: typeof plaintext;
+    progress: typeof progress;
+    rownum: typeof rownum;
+    star: typeof star;
+    tag: typeof tag;
+    textarea: typeof textarea;
+    tickCross: typeof tickCross;
+    toggle: typeof toggle;
+    traffic: typeof traffic;
+};
+export default _default;

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

@@ -0,0 +1,34 @@
+import { IColumn } 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';
+
+export default class FrozenColumns extends Module {
+    static moduleName: string;
+    leftColumns: IColumn[];
+    rightColumns: IColumn[];
+    initializationMode: 'left' | 'right';
+    active: boolean;
+    blocked: boolean;
+    constructor(table: any);
+    reset(): void;
+    initialize(): void;
+    blockLayout(): void;
+    unblockLayout(): void;
+    layoutCell(cell: Cell): void;
+    reinitializeColumns(): void;
+    initializeColumn(column: IColumn): void;
+    frozenCheck(column: IColumn): boolean;
+    layoutCalcRows(): void;
+    layoutGroupCalcs(groups: any[]): void;
+    layoutColumnPosition(allCells?: boolean): void;
+    getColGroupParentElement(column: IColumn): HTMLElement;
+    layout(): void;
+    reinitializeRows(): void;
+    layoutRow(row: Row): void;
+    layoutElement(element: HTMLElement | null, column: IColumn): void;
+    adjustForScrollbar(width: number): void;
+    getFrozenColumns(): IColumn[];
+    _calcSpace(columns: Column[], index: number): number;
+}

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

@@ -0,0 +1,22 @@
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+import { default as RowComponent } from '../../core/row/RowComponent';
+
+export default class FrozenRows extends Module {
+    static readonly moduleName = "frozenRows";
+    topElement: HTMLElement;
+    rows: Row[];
+    constructor(table: any);
+    initialize(): void;
+    resizeHolderWidth(): void;
+    initializeRows(): void;
+    initializeRow(row: Row): void;
+    isRowFrozen(row: RowComponent): boolean;
+    isFrozen(): boolean;
+    visibleRows(viewable: boolean, rows: Row[]): Row[];
+    getRows(rows: Row[]): Row[];
+    freezeRow(row: RowComponent): void;
+    unfreezeRow(row: RowComponent): void;
+    detachRow(row: Row): void;
+    styleRows(_row?: Row): void;
+}

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

@@ -0,0 +1,83 @@
+import { default as CxIconButton } from '../../../../icon-button/icon-button.ts';
+import { default as Row } from '../../core/row/Row';
+import { default as GroupComponent } from './GroupComponent';
+import { default as GroupRows } from './GroupRows';
+
+type GroupGenerator = (value: any, count: number, data: any[], component: GroupComponent) => string | HTMLElement;
+type GroupCalcs = {
+    bottom?: Row;
+    top?: Row;
+};
+export default class Group {
+    groupManager: GroupRows;
+    parent: Group | false;
+    key: any;
+    level: number;
+    field: string | false;
+    hasSubGroups: boolean;
+    addRow: (row: Row) => void;
+    type: string;
+    old: Group | false;
+    rows: Row[];
+    groups: Record<string, Group>;
+    groupList: Group[];
+    generator: GroupGenerator;
+    element: HTMLElement | false;
+    elementContents: string | HTMLElement | false;
+    height: number;
+    outerHeight: number;
+    initialized: boolean;
+    heightInitialized: boolean;
+    calcs: GroupCalcs;
+    modules: Record<string, any>;
+    arrowElement: CxIconButton | false;
+    visible: boolean | ((key: any, count: number, data: any[], component: GroupComponent) => boolean);
+    component: GroupComponent | null;
+    addBindingsFlag?: boolean;
+    constructor(groupManager: GroupRows, parent: Group | false, level: number, key: any, field: string | false, generator: GroupGenerator, oldGroup: Group | false);
+    wipe(elementsOnly?: boolean): void;
+    createElements(): void;
+    createValueGroups(): void;
+    addBindings(): void;
+    _createGroup(groupID: any, level: number): void;
+    _addRowToGroup(row: Row): void;
+    _addRow(row: Row): void;
+    setRowGroupLevel(row: Row): void;
+    clearRowGroupLevel(row: Row): void;
+    layoutRowGroupLevel(row: Row): void;
+    insertRow(row: Row, to: Row, after: boolean): void;
+    scrollHeader(left: string): void;
+    getRowIndex(_row: Row): void;
+    conformRowData(data: Record<string, any>): Record<string, any>;
+    removeRow(row: Row): void;
+    removeGroup(group: Group): void;
+    getHeadersAndRows(): Array<Group | Row>;
+    getData(visible?: boolean, transform?: string): any[];
+    getRowCount(): number;
+    toggleVisibility(): void;
+    hide(): void;
+    show(): void;
+    _visSet(): void;
+    getRowGroup(row: Row): Group | false;
+    getSubGroups(component?: boolean): Group[] | GroupComponent[];
+    getRows(component?: boolean, includeChildren?: boolean): Row[] | any[];
+    generateGroupHeaderContents(): void;
+    getPath(path?: any[]): any[];
+    getElement(): HTMLElement;
+    generateElement(): HTMLElement;
+    detachElement(): void;
+    normalizeHeight(): void;
+    initialize(force?: boolean): void;
+    reinitialize(): void;
+    setHeight(height: number): void;
+    getHeight(): number;
+    getGroup(): Group;
+    reinitializeHeight(): void;
+    calcHeight(): void;
+    setCellHeight(): void;
+    clearCellHeight(): void;
+    deinitializeHeight(): void;
+    rendered(): void;
+    getComponent(): GroupComponent;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { IGroupComponent, ITabulator, ScrollToRowPosition } from '../../../../../../../types/src/table';
+import { default as Group } from './Group';
+
+export default class GroupComponent implements IGroupComponent {
+    _group: Group;
+    type: string;
+    constructor(group: Group);
+    getKey(): any;
+    getField(): string | false;
+    getElement(): HTMLElement | false;
+    getRows(): any[];
+    getSubGroups(): any[];
+    getParentGroup(): GroupComponent | false;
+    isVisible(): boolean;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    scrollTo(position?: ScrollToRowPosition, ifVisible?: boolean): Promise<unknown> | undefined;
+    _getSelf(): Group;
+    getTable(): ITabulator;
+}

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

@@ -0,0 +1,69 @@
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+import { default as RowComponent } from '../../core/row/RowComponent';
+import { GroupArg, GroupValuesArg } from '../../core/types';
+import { default as Group } from './Group';
+import { default as GroupComponent } from './GroupComponent';
+
+type GroupIDLookup = {
+    field: string | false;
+    func: (data: any) => any;
+    values: any[] | false;
+};
+type GroupHeaderGenerator = (value: any, count: number, data: any[], component: GroupComponent) => string | HTMLElement;
+type GroupStartOpen = boolean | ((value: any, count: number, data: any[], component: GroupComponent) => boolean);
+export default class GroupRows extends Module {
+    static readonly moduleName = "groupRows";
+    groupIDLookups: GroupIDLookup[] | false;
+    startOpen: GroupStartOpen[];
+    headerGenerator: GroupHeaderGenerator[];
+    groupList: Group[];
+    allowedValues: GroupValuesArg | false;
+    groups: Record<string, Group>;
+    displayHandler: (rows: Row[]) => Row[];
+    blockRedraw: boolean;
+    initialized: boolean;
+    constructor(table: any);
+    initialize(): void;
+    layoutRowGroupLevel(row: Row): void;
+    _blockRedrawing(): void;
+    _restore_redrawing(): void;
+    configureGroupSetup(): void;
+    rowSample(rows: Row[], prevValue: Row[]): Row[];
+    virtualRenderFill(): Row[] | void;
+    rowAddingIndex(row: Row, index: Row | false, top: boolean): Row | false;
+    trackChanges(): void;
+    setGroupBy(groups: GroupArg | false): void;
+    setGroupValues(groupValues: GroupValuesArg): void;
+    setGroupStartOpen(values: GroupStartOpen | GroupStartOpen[]): void;
+    private updateGroupVisibility;
+    setGroupHeader(values: GroupHeaderGenerator | GroupHeaderGenerator[] | false): void;
+    userGetGroups(_values?: boolean): GroupComponent[];
+    userGetGroup(key: any): GroupComponent | false;
+    private findGroupByKey;
+    userGetGroupedData(): any[];
+    rowGetGroup(row: RowComponent): GroupComponent | false;
+    rowMoving(from: Row | Group, to: Row | Group, after: boolean): void;
+    rowDeleting(row: Row): void;
+    rowsUpdated(_row?: Row): void;
+    cellUpdated(cell: any): void;
+    getRows(rows: Row[]): Row[];
+    getGroups(component: boolean): Group[] | GroupComponent[];
+    getChildGroups(group?: Group): Group[];
+    wipe(): void;
+    pullGroupListData(groupList: Group[]): any[];
+    getGroupedData(): any[];
+    getRowGroup(row: Row): Group | false;
+    countGroups(): number;
+    generateGroups(rows: Row[]): void;
+    createGroup(groupID: any, level: number, oldGroups?: Record<string, Group>): void;
+    assignRowToExistingGroup(row: Row): void;
+    assignRowToGroup(row: Row, oldGroups?: Record<string, Group>): boolean;
+    reassignRowToGroup(row: Row): void;
+    getExpectedPath(row: Row): any[];
+    updateGroupRows(force?: boolean): Row[];
+    scrollHeaders(left: number): void;
+    removeGroup(group: Group): void;
+    checkBasicModeGroupHeaderWidth(): void;
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { default as Cell } from '../../core/cell/Cell';
+import { default as Module } from '../../core/Module';
+import { default as Row } from '../../core/row/Row';
+
+type HistoryActionType = 'cellEdit' | 'rowAdd' | 'rowDelete' | 'rowMove';
+type HistoryAction = {
+    component: Cell | Row;
+    data: {
+        after?: boolean;
+        data?: any;
+        index?: Row | false;
+        newValue?: any;
+        oldValue?: any;
+        pos?: boolean;
+        posFrom?: number | false;
+        posTo?: number | false;
+        to?: Row;
+    };
+    type: HistoryActionType;
+};
+type Undoer = (this: History, action: HistoryAction) => void;
+type Redoer = (this: History, action: HistoryAction) => void;
+export default class History extends Module {
+    static readonly moduleName = "history";
+    static readonly moduleExtensions: {
+        keybindings: {
+            actions: Record<string, (this: import('../..').KeybindingsModule, e: KeyboardEvent) => void>;
+            bindings: Record<string, string[]>;
+        };
+    };
+    static readonly undoers: Record<string, Undoer>;
+    static readonly redoers: Record<string, Redoer>;
+    history: HistoryAction[];
+    index: number;
+    constructor(table: any);
+    initialize(): void;
+    rowMoved(from: Row, to: Row, after: boolean): void;
+    rowAdded(row: Row, data: any, pos: boolean, index: Row | false): void;
+    rowDeleted(row: Row): void;
+    cellUpdated(cell: Cell): void;
+    clear(): void;
+    action(type: HistoryActionType, component: Cell | Row, data: HistoryAction['data']): void;
+    getHistoryUndoSize(): number;
+    getHistoryRedoSize(): number;
+    clearComponentHistory(component: Cell | Row): void;
+    undo(): boolean;
+    redo(): boolean;
+    _rebindRow(oldRow: Row, newRow: Row): void;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { default as Cell } from '../../../core/cell/Cell';
+import { default as Row } from '../../../core/row/Row';
+import { default as History } from '../History';
+
+type HistoryAction = {
+    component: Cell | Row;
+    data: {
+        after?: boolean;
+        data?: any;
+        index?: Row | false;
+        newValue?: any;
+        oldValue?: any;
+        pos?: boolean;
+        posFrom?: number | false;
+        posTo?: number | false;
+        to?: Row;
+    };
+    type: 'cellEdit' | 'rowAdd' | 'rowDelete' | 'rowMove';
+};
+type Redoer = (this: History, action: HistoryAction) => void;
+declare const redoers: Record<string, Redoer>;
+export default redoers;

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

@@ -0,0 +1,22 @@
+import { default as Cell } from '../../../core/cell/Cell';
+import { default as Row } from '../../../core/row/Row';
+import { default as History } from '../History';
+
+type HistoryAction = {
+    component: Cell | Row;
+    data: {
+        after?: boolean;
+        data?: any;
+        index?: Row | false;
+        newValue?: any;
+        oldValue?: any;
+        pos?: boolean;
+        posFrom?: number | false;
+        posTo?: number | false;
+        to?: Row;
+    };
+    type: 'cellEdit' | 'rowAdd' | 'rowDelete' | 'rowMove';
+};
+type Undoer = (this: History, action: HistoryAction) => void;
+declare const undoers: Record<string, Undoer>;
+export default undoers;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/History/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[]>;
+    };
+};
+export default extensions;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/History/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/History/extensions/keybindings/bindings.d.ts

@@ -0,0 +1,2 @@
+declare const bindings: Record<string, string[]>;
+export default bindings;

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

@@ -0,0 +1,17 @@
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+
+export default class HtmlTableImport extends Module {
+    static readonly moduleName = "htmlTableImport";
+    fieldIndex: Array<string | undefined>;
+    hasIndex: boolean;
+    constructor(table: Tabulator);
+    initialize(): void;
+    tableElementCheck(): void;
+    parseTable(): void;
+    _extractOptions(element: HTMLElement, options: Record<string, any>, defaultOptions?: Record<string, any>): void;
+    _attribValue(value: string | null): string | boolean;
+    _findCol(title: string | null): Record<string, any> | false;
+    _extractHeaders(headers: HTMLCollectionOf<HTMLTableHeaderCellElement>, _rows: HTMLCollectionOf<HTMLTableRowElement>): void;
+    _generateBlankHeaders(headers: HTMLCollectionOf<HTMLTableHeaderCellElement>, _rows: HTMLCollectionOf<HTMLTableRowElement>): void;
+}

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

@@ -0,0 +1,29 @@
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+
+export default class Import extends Module {
+    static readonly moduleName = "import";
+    static readonly importers: {
+        array: typeof import('./defaults/importers/array').default;
+        csv: typeof import('./defaults/importers/csv').default;
+        json: typeof import('./defaults/importers/json').default;
+        xlsx: (this: Tabulator, input: ArrayBuffer | string) => any[][];
+    };
+    constructor(table: Tabulator);
+    initialize(): void;
+    loadDataCheck(data: any): boolean;
+    loadData(data: any, _params: any, _config: any, _silent: any, _previousData: any): Promise<any>;
+    lookupImporter(importFormat?: string | ((...args: any[]) => any)): any;
+    importFromFile(importFormat?: string | ((...args: any[]) => any), extension?: string, importReader?: string): Promise<any> | undefined;
+    pickFile(extensions?: string, importReader?: string): Promise<string | ArrayBuffer>;
+    importData(importer: (...args: any[]) => any, fileContents: string | ArrayBuffer): Promise<any>;
+    structureData(parsedData: any): any;
+    mutateData(data: any): any;
+    transformHeader(headers: any[]): any[];
+    transformData(row: any[]): any[];
+    structureArrayToObject(parsedData: any[][]): Array<Record<string, any>>;
+    structureArrayToColumns(parsedData: any[][]): Array<Record<string, any>>;
+    validateFile(file: File): boolean | any;
+    validateData(data: any): Promise<any> | any;
+    setData(data: any): Promise<any>;
+}

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Import/defaults/importers/array.d.ts

@@ -0,0 +1 @@
+export default function (input: any): any;

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

@@ -0,0 +1 @@
+export default function (input: string): string[][];

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

@@ -0,0 +1 @@
+export default function json(input: string): Promise<any>;

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

@@ -0,0 +1,5 @@
+import { default as Tabulator } from '../../../../core/Tabulator';
+
+type XLSXImporter = (this: Tabulator, input: ArrayBuffer | string) => any[][];
+declare const xlsx: XLSXImporter;
+export default xlsx;

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

@@ -0,0 +1,11 @@
+import { default as array } from './importers/array';
+import { default as csv } from './importers/csv';
+import { default as json } from './importers/json';
+
+declare const _default: {
+    array: typeof array;
+    csv: typeof csv;
+    json: typeof json;
+    xlsx: (this: import('../../..').Tabulator, input: ArrayBuffer | string) => any[][];
+};
+export default _default;

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

@@ -0,0 +1,37 @@
+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 Tabulator } from '../../core/Tabulator';
+
+type TouchWatcher = {
+    tap: boolean;
+    tapDbl: ReturnType<typeof setTimeout> | null;
+    tapHold: ReturnType<typeof setTimeout> | null;
+};
+type TouchWatchers = {
+    cell: TouchWatcher;
+    column: TouchWatcher;
+    group: TouchWatcher;
+    row: TouchWatcher;
+};
+export default class Interaction extends Module {
+    static moduleName: string;
+    eventMap: Record<string, string>;
+    subscribers: Record<string, any>;
+    touchSubscribers: Record<string, any>;
+    columnSubscribers: Record<string, Column[]>;
+    touchWatchers: TouchWatchers;
+    constructor(table: Tabulator);
+    initialize(): void;
+    clearTouchWatchers(): void;
+    cellContentsSelectionFixer(e: Event, cell: Cell): void;
+    initializeExternalEvents(): void;
+    subscriptionChanged(key: string, added: boolean): void;
+    subscribeTouchEvents(key: string): void;
+    unsubscribeTouchEvents(key: string): void;
+    initializeColumn(column: Column): void;
+    handle(action: string, e: Event, component: Cell | Column): void;
+    handleTouch(type: string, action: string, e: Event, component: Cell | Column): void;
+    dispatchEvent(action: string, e: Event, component: Cell | Column): void;
+}
+export {};

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

@@ -0,0 +1,38 @@
+import { default as Module } from '../../core/Module';
+import { default as Tabulator } from '../../core/Tabulator';
+
+type Binding = {
+    action: (this: Keybindings, e: KeyboardEvent) => void;
+    ctrl: boolean;
+    keys: number[];
+    meta: boolean;
+    shift: boolean;
+};
+export default class Keybindings extends Module {
+    static readonly moduleName = "keybindings";
+    static readonly bindings: {
+        navDown: number;
+        navLeft: number;
+        navNext: number;
+        navPrev: string;
+        navRight: number;
+        navUp: number;
+        scrollPageDown: number;
+        scrollPageUp: number;
+        scrollToEnd: number;
+        scrollToStart: number;
+    };
+    static readonly actions: Record<string, (this: Keybindings, e: KeyboardEvent) => void>;
+    watchKeys: Record<number, Binding[]> | null;
+    pressedKeys: number[] | null;
+    keyupBinding: ((e: KeyboardEvent) => void) | false;
+    keydownBinding: ((e: KeyboardEvent) => void) | false;
+    constructor(table: Tabulator);
+    initialize(): void;
+    mapBindings(bindings: Record<string, any>): void;
+    mapBinding(action: string, symbolsList: string | number): void;
+    bindEvents(): void;
+    clearBindings(): void;
+    checkBinding(e: KeyboardEvent, binding: Binding): boolean;
+}
+export {};

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

@@ -0,0 +1,5 @@
+import { default as Keybindings } from '../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/Keybindings/defaults/bindings.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    navDown: number;
+    navLeft: number;
+    navNext: number;
+    navPrev: string;
+    navRight: number;
+    navUp: number;
+    scrollPageDown: number;
+    scrollPageUp: number;
+    scrollToEnd: number;
+    scrollToStart: number;
+};
+export default _default;

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

@@ -0,0 +1,17 @@
+import { ITabulator } from '../../../../../../../types/src/table';
+import { default as Column } from '../../core/column/Column';
+import { default as Module } from '../../core/Module';
+
+type LayoutMode = 'fitData' | 'fitColumns' | 'fitDataFill' | 'fitDataStretch' | 'fitDataTable';
+type LayoutModeFunction = (this: Layout, columns: Column[], dataChanged?: boolean) => void | Promise<void>;
+export default class Layout extends Module {
+    static moduleName: string;
+    static modes: Record<LayoutMode, LayoutModeFunction>;
+    mode: LayoutMode | null;
+    constructor(table: ITabulator);
+    initialize(): void;
+    initializeColumn(column: Column): void;
+    getMode(): LayoutMode | null;
+    layout(dataChanged?: boolean): Promise<void>;
+}
+export {};

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Layout/defaults/modes/fitColumns.d.ts

@@ -0,0 +1,4 @@
+import { default as Column } from '../../../../core/column/Column';
+import { default as Layout } from '../../Layout';
+
+export default function (this: Layout, columns: Column[]): void;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Layout/defaults/modes/fitData.d.ts

@@ -0,0 +1,4 @@
+import { default as Column } from '../../../../core/column/Column';
+import { default as Layout } from '../../Layout';
+
+export default function (this: Layout, columns: Column[], forced?: boolean): Promise<void>;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Layout/defaults/modes/fitDataGeneral.d.ts

@@ -0,0 +1,4 @@
+import { default as Column } from '../../../../core/column/Column';
+import { default as Layout } from '../../Layout';
+
+export default function (this: Layout, columns: Column[]): Promise<void>;

package/library/packages/atoms/src/components/table/tabulator-tables/modules/Layout/defaults/modes/fitDataStretch.d.ts

@@ -0,0 +1,4 @@
+import { default as Column } from '../../../../core/column/Column';
+import { default as Layout } from '../../Layout';
+
+export default function (this: Layout, columns: Column[]): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { default as fitColumns } from './modes/fitColumns';
+import { default as fitData } from './modes/fitData';
+import { default as fitDataGeneral } from './modes/fitDataGeneral';
+import { default as fitDataStretch } from './modes/fitDataStretch';
+
+declare const _default: {
+    fitColumns: typeof fitColumns;
+    fitData: typeof fitData;
+    fitDataFill: typeof fitDataGeneral;
+    fitDataStretch: typeof fitDataStretch;
+    fitDataTable: typeof fitDataGeneral;
+};
+export default _default;