@dhtmlx/vault 5.0.6

package/codebase/types/ts-grid/sources/ui/cells.d.ts

@@ -0,0 +1,34 @@
+import { GridEvents, GridSystemEvents, ICoords, IGridConfig, IRendererConfig, ISpan, Split } from "../types";
+import { IDataCollection } from "../../../ts-data";
+type mouseEvents = GridEvents.cellClick | GridEvents.cellMouseOver | GridEvents.cellMouseDown | GridEvents.cellDblClick | GridEvents.cellRightClick;
+type touchEvents = GridSystemEvents.cellTouchEnd | GridSystemEvents.cellTouchMove;
+declare function handleMouse(rowStart: number, colStart: number, conf: IRendererConfig, type: mouseEvents & touchEvents, e: any): void;
+export declare function getHandlers(row: number, column: number, conf: IRendererConfig): {
+    onclick: (number | GridEvents | IRendererConfig | typeof handleMouse)[];
+    onmouseover: (number | GridEvents | IRendererConfig | typeof handleMouse)[];
+    onmousedown: (number | GridEvents | IRendererConfig | typeof handleMouse)[];
+    ondblclick: (number | GridEvents | IRendererConfig | typeof handleMouse)[];
+    oncontextmenu: (number | GridEvents | IRendererConfig | typeof handleMouse)[];
+    ontouchstart: (number | GridEvents | IRendererConfig | typeof handleMouse)[];
+    ontouchmove: (number | GridSystemEvents | IRendererConfig | typeof handleMouse)[];
+    ontouchend: (number | GridSystemEvents | IRendererConfig | typeof handleMouse)[];
+};
+export declare function getCells(conf: IRendererConfig): any[];
+export declare function getSpans(config: IRendererConfig, mode?: Split): any[];
+export declare function getShifts(conf: IRendererConfig): ICoords;
+export declare function normalizeSpan(span: ISpan, config: IGridConfig, data: IDataCollection): {
+    $renderFrom: any[];
+    $rowsVisibility: number[];
+    $colsVisibility: number[];
+    row: import("../../../ts-common/types").Id;
+    column: import("../../../ts-common/types").Id;
+    rowspan?: number;
+    colspan?: number;
+    text?: string | ((args: import("../types").ISummaryList) => string);
+    css?: string;
+    tooltip?: boolean | import("../types").IGridTooltipConfig;
+    tooltipTemplate?: (content: {
+        value: string;
+    } & import("../types").ISummaryList, span: ISpan) => string | boolean;
+};
+export {};

package/codebase/types/ts-grid/sources/ui/common.d.ts

@@ -0,0 +1,8 @@
+import { IGridConfig, IRendererConfig, IScrollBarWidth, Split } from "../types";
+export declare const BORDERS = 2;
+export declare function calcScrollBarWidth(config: IGridConfig | IRendererConfig, customScroll?: boolean, sizes?: {
+    width: number;
+    height: number;
+}): IScrollBarWidth;
+export declare function getCurrFixedCols(config: IGridConfig, split: Split.left | Split.right): import("../types").ICol[];
+export declare function getNormalizeDateObject(item: string | Date, dateFormat: string): Date | null;

package/codebase/types/ts-grid/sources/ui/components/dragPanel.d.ts

@@ -0,0 +1,7 @@
+import { VNode } from "../../../../ts-common/dom";
+import { ILayoutState, IProGrid, IRendererConfig } from "../../types";
+export interface IDragPanelState {
+    lessHeight: boolean;
+    footerAtBottom: boolean;
+}
+export declare function getDragPanelNode(grid: IProGrid, config: IRendererConfig, scroll: ILayoutState, lessByHeight?: boolean): VNode;

package/codebase/types/ts-grid/sources/ui/components/groupPanel.d.ts

@@ -0,0 +1,13 @@
+import { IProGrid } from "../../types";
+export interface IGroupItem {
+    id: string;
+    label: string;
+    closable?: boolean;
+    sortable?: boolean;
+    sortDir?: "asc" | "desc" | null;
+    sortOrder?: number | null;
+    mode?: "basic" | "drop";
+    notGrouped?: boolean;
+}
+export declare function getGroupItem({ id, label, sortDir, sortOrder, mode, sortable, closable, }: IGroupItem): any;
+export declare function getGroupPanel(grouped: IGroupItem[], grid: IProGrid): any;

package/codebase/types/ts-grid/sources/ui/components/subRow.d.ts

@@ -0,0 +1,4 @@
+import { VNode } from "../../../../ts-common/dom";
+import { IProGrid, IRendererConfig, IRow } from "../../types";
+export declare function getSubRowContent(config: IRendererConfig): VNode[];
+export declare function setSubRowCell(grid: IProGrid, rows: IRow[]): void;

package/codebase/types/ts-grid/sources/ui/content/ComboFilter.d.ts

@@ -0,0 +1,35 @@
+import { ProCombobox } from "../../../../ts-combobox";
+import { IEventSystem } from "../../../../ts-common/events";
+import { IDataItem } from "../../../../ts-data";
+import { ICol, IRendererConfig } from "../../types";
+import { HeaderFilterEvent, IComboFilterConfig, IHeaderFilter } from "../content";
+export declare class ComboFilter implements IHeaderFilter {
+    column: ICol;
+    config: IRendererConfig;
+    data: string[] | IDataItem[];
+    value: string | string[];
+    filterConfig: IComboFilterConfig;
+    events: IEventSystem<HeaderFilterEvent>;
+    private _filter;
+    private _grid;
+    private _isFocused;
+    private _silentMode;
+    constructor({ column, config, headerConfig, uniqueData, value, grid }: {
+        column: any;
+        config: any;
+        headerConfig: any;
+        uniqueData: any;
+        value: any;
+        grid: any;
+    });
+    protected initFilter(): void;
+    protected initHandlers(): void;
+    getFilter(): ProCombobox;
+    setValue(value: string | string[], silent?: boolean): void;
+    clear(silent?: boolean): void;
+    focus(): void;
+    blur(): void;
+    destructor(): void;
+    private _setData;
+    private _checkValue;
+}

package/codebase/types/ts-grid/sources/ui/content/DateFilter.d.ts

@@ -0,0 +1,42 @@
+import { IEventSystem } from "../../../../ts-common/events";
+import { ICol, IEventHandlersMap, IRendererConfig } from "../../types";
+import { HeaderFilterEvent } from "../content";
+import { IDateFilterConfig, IProHeaderFilter } from "../proContent";
+import { Calendar } from "../../../../ts-calendar";
+import { VNode } from "../../../../ts-common/dom";
+import { Id } from "../../../../ts-common/types";
+export declare class DateFilter implements IProHeaderFilter {
+    id: Id;
+    column: ICol;
+    config: IRendererConfig;
+    events: IEventSystem<HeaderFilterEvent, IEventHandlersMap>;
+    filterConfig: IDateFilterConfig;
+    value: Date | Date[];
+    private _calendar;
+    private _popup;
+    private _handlers;
+    private _grid;
+    private _keyManager;
+    constructor({ column, config, headerConfig, value, id, grid }: {
+        column: any;
+        config: any;
+        headerConfig: any;
+        value: any;
+        id: any;
+        grid: any;
+    });
+    getFilter(): Calendar;
+    setValue(value: Date | Date[] | null, silent?: boolean): void;
+    clear(): void;
+    focus(): void;
+    blur(): void;
+    destructor(): void;
+    toHTML(): VNode;
+    private _initFilter;
+    private _initHandlers;
+    private shouldUpdateCalendar;
+    private _getRootElement;
+    private _changeTab;
+    private _showPopup;
+    private _initHotkeys;
+}

package/codebase/types/ts-grid/sources/ui/content/InputFilter.d.ts

@@ -0,0 +1,32 @@
+import { VNode } from "../../../../ts-common/dom";
+import { IEventSystem } from "../../../../ts-common/events";
+import { Id } from "../../../../ts-common/types";
+import { IBaseHandlersMap, ICol, IRendererConfig } from "../../types";
+import { HeaderFilterEvent, IHeaderFilter, IInputFilterConfig } from "../content";
+export declare class InputFilter implements IHeaderFilter {
+    column: ICol;
+    config: IRendererConfig;
+    value: string;
+    id: Id;
+    events: IEventSystem<HeaderFilterEvent>;
+    filterConfig: IInputFilterConfig;
+    protected _handlers: IBaseHandlersMap;
+    protected _inputDelay: any;
+    private _isFocused;
+    private _grid;
+    constructor({ column, config, id, value, headerConfig, grid }: {
+        column: any;
+        config: any;
+        id: any;
+        value: any;
+        headerConfig: any;
+        grid: any;
+    });
+    toHTML(): VNode;
+    getFilter(): any;
+    setValue(value: string, silent?: boolean): void;
+    clear(silent?: boolean): void;
+    focus(): void;
+    blur(): void;
+    private initHandlers;
+}

package/codebase/types/ts-grid/sources/ui/content/SelectFilter.d.ts

@@ -0,0 +1,28 @@
+import { VNode } from "../../../../ts-common/dom";
+import { IEventSystem } from "../../../../ts-common/events";
+import { IBaseHandlersMap, ICol, IRendererConfig } from "../../types";
+import { HeaderFilterEvent, IHeaderFilter } from "../content";
+export declare class SelectFilter implements IHeaderFilter {
+    column: ICol;
+    config: IRendererConfig;
+    data: any[];
+    value: string;
+    events: IEventSystem<HeaderFilterEvent>;
+    protected _handlers: IBaseHandlersMap;
+    private _isFocused;
+    private _grid;
+    constructor({ column, config, uniqueData, value, grid }: {
+        column: any;
+        config: any;
+        uniqueData?: any[];
+        value: any;
+        grid: any;
+    });
+    toHTML(): VNode;
+    getFilter(): any;
+    setValue(value: string, silent?: boolean): void;
+    clear(silent?: boolean): void;
+    focus(): void;
+    blur(): void;
+    private initHandlers;
+}

package/codebase/types/ts-grid/sources/ui/content.d.ts

@@ -0,0 +1,55 @@
+import { VNode } from "../../../ts-common/dom";
+import { ICol, IExtendedGrid, IGrid, IProGrid, IRendererConfig } from "../types";
+import { DataCollection, IDataItem } from "../../../ts-data";
+import { Combobox } from "../../../ts-combobox";
+import { IEventSystem } from "../../../ts-common/events";
+import { Id } from "../../../ts-common/types";
+export interface IComboFilterConfig {
+    template?: (item: IDataItem) => string;
+    filter?: (item: IDataItem, input: string) => boolean;
+    data?: DataCollection<IDataItem> | IDataItem[];
+    placeholder?: string;
+    readonly?: boolean;
+    virtual?: boolean;
+    multiselection?: boolean;
+}
+export interface IInputFilterConfig {
+    placeholder?: string;
+    icon?: string;
+}
+export declare enum HeaderFilterEvent {
+    change = "change"
+}
+export interface IHeaderFilter {
+    column: ICol;
+    config: IRendererConfig;
+    value: string | string[];
+    events: IEventSystem<HeaderFilterEvent>;
+    data?: string[] | IDataItem[];
+    id?: Id;
+    filterConfig?: IComboFilterConfig | IInputFilterConfig;
+    getFilter(): VNode | Combobox;
+    setValue(value: string | string[], silent?: boolean): void;
+    clear(silent?: boolean): void;
+    focus(): void;
+    blur(): void;
+}
+export interface ICellContent {
+    toHtml: (column: ICol, config: IRendererConfig) => VNode;
+    match?: (obj: IMatch) => boolean;
+    destructor?: () => void;
+    element?: Record<string, IHeaderFilter>;
+    value?: Record<string, string>;
+}
+interface IMatch {
+    val: number | string | Date;
+    match: string | string[] | Date | Date[];
+    obj: IDataItem;
+    col?: ICol;
+    multi?: boolean;
+}
+export interface IContentList {
+    [key: string]: ICellContent;
+}
+export declare function getContent(grid: IGrid | IProGrid | IExtendedGrid): IContentList;
+export {};

package/codebase/types/ts-grid/sources/ui/editors/CheckboxEditor.d.ts

@@ -0,0 +1,18 @@
+import { ICol, IRendererConfig, IRow, IEditor } from "../../types";
+export declare class CheckboxEditor implements IEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _cell: {
+        row: IRow;
+        col: ICol;
+    };
+    protected _config: IRendererConfig;
+    protected _checkbox: HTMLInputElement;
+    protected _input: HTMLInputElement;
+    protected _checked: boolean;
+    constructor(row: IRow, col: ICol, config: IRendererConfig);
+    endEdit(): void;
+    toHTML(): any;
+    protected _initHandlers(): void;
+}

package/codebase/types/ts-grid/sources/ui/editors/ComboboxEditor.d.ts

@@ -0,0 +1,18 @@
+import { ICol, IRendererConfig, IEditor, IRow } from "../../types";
+import { ProCombobox } from "../../../../ts-combobox";
+export declare class ComboboxEditor implements IEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _cell: {
+        row: IRow;
+        col: ICol;
+    };
+    protected _config: IRendererConfig;
+    protected _input: ProCombobox;
+    constructor(row: any, col: ICol, config: IRendererConfig);
+    endEdit(withoutSave?: boolean): void;
+    toHTML(): any;
+    protected _initHandlers(): void;
+    private _setCustomOptions;
+}

package/codebase/types/ts-grid/sources/ui/editors/DateEditor.d.ts

@@ -0,0 +1,37 @@
+import { ICol, IRendererConfig, IRow, IEditor } from "../../types";
+export declare class DateEditor implements IEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _cell: {
+        row: IRow;
+        col: ICol;
+    };
+    protected _config: IRendererConfig;
+    protected _input: HTMLInputElement;
+    private _calendar;
+    private _popup;
+    private _value;
+    private _editorConfig;
+    constructor(row: IRow, col: ICol, config: IRendererConfig);
+    endEdit(withoutSave?: boolean, calendarChange?: boolean): void;
+    toHTML(): any;
+    protected _cleanConfig(col: ICol): {
+        date?: string | Date;
+        css?: string;
+        mark?: (a: Date) => string;
+        disabledDates?: (a: Date) => boolean;
+        weekStart?: "saturday" | "sunday" | "monday";
+        weekNumbers?: boolean;
+        mode?: import("../../../../ts-calendar").ViewMode;
+        timePicker?: boolean;
+        timeFormat?: 12 | 24;
+        thisMonthOnly?: boolean;
+        width?: string | number;
+        $rangeMark?: (a: Date) => string;
+        block?: (a: Date) => boolean;
+        view?: import("../../../../ts-calendar").ViewMode;
+    };
+    protected _initHandlers(): void;
+    private _getValue;
+}

package/codebase/types/ts-grid/sources/ui/editors/InputEditor.d.ts

@@ -0,0 +1,22 @@
+import { ICol, IRendererConfig, IRow, IEditor } from "../../types";
+export declare class InputEditor implements IEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _cell: {
+        row: IRow;
+        col: ICol;
+    };
+    protected _config: IRendererConfig;
+    protected _input: HTMLInputElement;
+    private prevValue;
+    private type;
+    constructor(row: IRow, col: ICol, config: IRendererConfig);
+    endEdit(withoutSave?: boolean): void;
+    toHTML(value?: string | number): any;
+    protected _initHandlers(): void;
+    private _isValidWord;
+    private _isCorrectRange;
+    private _applyValuePattern;
+    private _removeValuePattern;
+}

package/codebase/types/ts-grid/sources/ui/editors/SelectEditor.d.ts

@@ -0,0 +1,16 @@
+import { ICol, IRendererConfig, IEditor, IRow } from "../../types";
+export declare class SelectEditor implements IEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _cell: {
+        row: IRow;
+        col: ICol;
+    };
+    protected _config: IRendererConfig;
+    protected _input: HTMLSelectElement;
+    constructor(row: any, col: ICol, config: IRendererConfig);
+    endEdit(withoutSave?: boolean): void;
+    toHTML(): any;
+    protected _initHandlers(): void;
+}

package/codebase/types/ts-grid/sources/ui/editors/TextAreaEditor.d.ts

@@ -0,0 +1,27 @@
+import { ICol, IRendererConfig, IRow, IEditor, ISpan } from "../../types";
+export declare class TextAreaEditor implements IEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _cell: {
+        row: IRow;
+        col: ICol;
+    };
+    protected _config: IRendererConfig;
+    protected _input: HTMLTextAreaElement;
+    private type;
+    private _minHeight;
+    private _prevHeight;
+    private _width;
+    private _initialValue;
+    constructor(row: IRow, col: ICol, config: IRendererConfig, span?: ISpan);
+    endEdit(withoutSave?: boolean): void;
+    toHTML(value?: string): any;
+    protected _initHandlers(): void;
+    private _getCurrentHeight;
+    private _getElementHeight;
+    private _applyValuePattern;
+    private _removeValuePattern;
+    private _getCellWidth;
+    private _updateHeight;
+}

package/codebase/types/ts-grid/sources/ui/editors/editors.d.ts

@@ -0,0 +1,2 @@
+import { IRendererConfig, ICol, IEditor, ISpan } from "../../types";
+export declare function getEditor(row: any, col: ICol, conf: IRendererConfig, span?: ISpan): IEditor;

package/codebase/types/ts-grid/sources/ui/proContent.d.ts

@@ -0,0 +1,37 @@
+import { IExtendedGrid, IProGrid } from "../types";
+import { ICellContent, IHeaderFilter } from "./content";
+import { VNode } from "../../../ts-common/dom";
+import { DataCollection, IDataItem } from "../../../ts-data";
+import { Calendar, ICalendarConfig } from "../../../ts-calendar";
+import { Combobox } from "../../../ts-combobox";
+export interface IComboFilterConfig {
+    template?: (item: IDataItem) => string;
+    filter?: (item: IDataItem, input: string) => boolean;
+    data?: DataCollection<IDataItem> | IDataItem[];
+    placeholder?: string;
+    readonly?: boolean;
+    virtual?: boolean;
+    multiselection?: boolean;
+}
+export interface IInputFilterConfig {
+    placeholder?: string;
+    icon?: string;
+}
+export interface IDateFilterConfig extends Omit<ICalendarConfig, "value" | "css" | "$rangeMark"> {
+    icon?: string;
+    placeholder?: string;
+    asDateObject?: boolean;
+}
+export interface IProHeaderFilter extends Omit<IHeaderFilter, "value" | "filterConfig"> {
+    value: string | string[] | Date | Date[];
+    filterConfig?: IComboFilterConfig | IDateFilterConfig | IInputFilterConfig;
+    getFilter(): VNode | Combobox | Calendar;
+    setValue(value: string | string[] | Date | Date[], silent?: boolean): void;
+}
+export interface IProCellContent extends Omit<ICellContent, "element"> {
+    element?: Record<string, IProHeaderFilter>;
+}
+export interface IProContentList {
+    [key: string]: IProCellContent;
+}
+export declare function getProContent(grid: IProGrid | IExtendedGrid): IProContentList;

package/codebase/types/ts-grid/sources/ui/render.d.ts

@@ -0,0 +1,9 @@
+import { IGrid, IGridConfig, IProGrid, IRendererConfig, IRow, ISizes } from "../types";
+export declare function getRenderConfig(obj: any, data: IRow[], wrapperSizes: ISizes): IRendererConfig;
+export declare function getElementSizes(element: HTMLElement | any): {
+    width: number;
+    height: number;
+};
+export declare function applyAutoWidth(config: IGridConfig, wrapperSizes: any, scrollViewConfig?: boolean): void;
+export declare function render(vm: any, obj: IGrid, htmlEvents: any, selection: any, uid: string): any;
+export declare function proRender(vm: any, obj: IProGrid, htmlEvents: any, selection: any, uid: string): any;

package/codebase/types/ts-layout/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sources/Layout";
+export * from "./sources/ProLayout";
+export * from "./sources/types";

package/codebase/types/ts-layout/sources/Cell.d.ts

@@ -0,0 +1,60 @@
+import { IViewLike, View } from "../../ts-common/view";
+import { ICell, ICellConfig, ILayout, LayoutEvents, ILayoutEventHandlersMap } from "./types";
+import { IEventSystem } from "../../ts-common/events";
+import { ScrollView } from "../../ts-common/ScrollView";
+export declare class Cell extends View implements ICell {
+    id: string;
+    config: ICellConfig;
+    events: IEventSystem<LayoutEvents, ILayoutEventHandlersMap>;
+    scrollView: ScrollView;
+    protected _handlers: {
+        [key: string]: (...args: any) => any;
+    };
+    protected _disabled: string[];
+    protected _parent: ILayout;
+    protected _ui: IViewLike;
+    protected _resizerHandlers: any;
+    protected _progress: boolean;
+    protected _stopProgressDefault: boolean;
+    protected _theme: string;
+    private _isLastFlexCell;
+    private _afterWindowResized;
+    constructor(parent: string | HTMLElement | ILayout, config: ICellConfig);
+    paint(): void;
+    isVisible(): boolean;
+    hide(): void;
+    show(): void;
+    expand(): void;
+    collapse(): void;
+    toggle(): void;
+    protected _checkNextSize(cell?: ICell): any;
+    getParent(): ILayout;
+    destructor(): void;
+    getWidget(): IViewLike;
+    getCellView(): any;
+    attach(component: any, config?: any): IViewLike;
+    attachHTML(html: string): void;
+    detach(): void;
+    progressShow(): void;
+    progressHide(): void;
+    isVisibleProgress(): boolean;
+    toVDOM(nodes?: any[]): any;
+    protected _saveTheme(): void;
+    protected _getProgressBar(): any;
+    protected _getCss(_content?: boolean): string;
+    protected _initHandlers(): void;
+    protected _getCollapsedSize(cell: ICell, nextCell: ICell): number;
+    protected _getCollapseIcon(): "dxi dxi-chevron-right" | "dxi dxi-chevron-left" | "dxi dxi-chevron-up" | "dxi dxi-chevron-down";
+    protected _isLastCell(): boolean;
+    protected _getNextCell(): any;
+    protected _getAnyFlexCell(selfInclude?: boolean): any;
+    protected _getResizerView(): any;
+    protected _isXDirection(): any;
+    protected _checkProgress(): boolean;
+    protected _checkAutoProgress(): boolean;
+    protected _calculateProgressState(): void;
+    protected _calculateStyle(): any;
+    private _resizedWindow;
+    private _resetCellsSize;
+    private _checkFullSizeCell;
+}

package/codebase/types/ts-layout/sources/Layout.d.ts

@@ -0,0 +1,29 @@
+import { ICell, ICellConfig, ILayout, ILayoutConfig, LayoutCallback } from "./types";
+import { Cell } from "./Cell";
+export declare class Layout extends Cell implements ILayout {
+    config: ILayoutConfig;
+    protected _all: any;
+    protected _cells: ICell[];
+    protected _root: ILayout;
+    protected _progress: boolean;
+    private _xLayout;
+    private _isViewLayout;
+    constructor(parent: any, config: ILayoutConfig);
+    destructor(): void;
+    toVDOM(): any;
+    removeCell(id: string): void;
+    getId(index: number): string;
+    getRefs(name: string): any;
+    getCell(id: string): any;
+    forEach(callback: LayoutCallback, parent?: string, level?: number): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    cell(id: string): any;
+    progressShow(): void;
+    progressHide(): void;
+    protected _addCell(config: ICellConfig, index?: number): void;
+    protected _getCss(content?: boolean): string;
+    private _parseConfig;
+    protected _createCell(cell: ILayoutConfig): ICell;
+    private _haveCells;
+    private _inheritTypes;
+}

package/codebase/types/ts-layout/sources/ProCell.d.ts

@@ -0,0 +1,9 @@
+import { ScrollView } from "../../ts-common/ScrollView";
+import { Cell } from "./Cell";
+import { ILayout, ICellConfig, IProCell } from "./types";
+export declare class ProCell extends Cell implements IProCell {
+    scrollView: ScrollView;
+    constructor(parent: string | HTMLElement | ILayout | null, config: ICellConfig);
+    private _getFirstRootView;
+    toVDOM(nodes?: any[]): any;
+}

package/codebase/types/ts-layout/sources/ProLayout.d.ts

@@ -0,0 +1,6 @@
+import { ILayout, ILayoutConfig, ICell } from "./types";
+import { Layout } from "./Layout";
+export declare class ProLayout extends Layout implements ILayout {
+    constructor(parent: any, config: ILayoutConfig);
+    protected _createCell(cell: ILayoutConfig): ICell;
+}

package/codebase/types/ts-layout/sources/helpers.d.ts

@@ -0,0 +1,6 @@
+import { ICellConfig } from "./types";
+export declare function getBlockRange(block1: ClientRect, block2: ClientRect, isXLayout?: boolean): {
+    min: number;
+    max: number;
+};
+export declare function getMarginSize(config: ICellConfig): 0 | 12;