@dhtmlx/vault 5.0.6

package/codebase/types/ts-navbar/sources/types.d.ts

@@ -0,0 +1,210 @@
+import { Id } from "../../ts-common/types";
+import { IEventSystem } from "../../ts-common/events";
+import { DataEvents, IDataEventsHandlersMap, IDataItem, TreeCollection } from "../../ts-data";
+import { Calendar, ViewMode } from "../../ts-calendar";
+import { Popup } from "../../ts-popup";
+export { DataEvents } from "../../ts-data";
+export interface IHtmlExtendable {
+    html?: string;
+}
+export interface IState {
+    [key: string]: string | boolean;
+}
+export type NavigationType = "pointer" | "click";
+export interface IGroups {
+    [key: string]: {
+        active?: Id;
+        elements: string[];
+    };
+}
+export type ContextMode = "bottom" | "right";
+export interface INavbarConfig {
+    navigationType?: NavigationType;
+    css?: string;
+    menuCss?: string;
+    data?: any[] | TreeCollection<any>;
+    rootId?: string;
+    $name?: string;
+}
+export interface INavbar {
+    data: TreeCollection;
+    events: IEventSystem<DataEvents | NavigationBarEvents, IDataEventsHandlersMap & INavbarEventHandlersMap>;
+    config: INavbarConfig;
+    paint(): void;
+    disable(ids: Id | Id[]): void;
+    enable(ids: Id | Id[]): void;
+    isDisabled(id: Id): boolean;
+    show(ids: Id | Id[]): void;
+    hide(ids: Id | Id[]): void;
+    destructor(): void;
+    select(id: Id, unselect: boolean): void;
+    unselect(id?: Id): void;
+    isSelected(id: Id): boolean;
+    getSelected(): Id[];
+}
+export type ItemType = "button" | "imageButton" | "selectButton" | "customButton" | "input" | "separator" | "title" | "spacer" | "menuItem" | "block" | "navItem" | "customHTML" | "customHTMLButton" | "datePicker";
+export interface IItem extends IDataItem {
+    id?: Id;
+    type?: ItemType;
+    parent?: Id;
+    css?: string | string[];
+    hidden?: boolean;
+    disabled?: boolean;
+}
+export type IMenuElement = ISpacer | ISeparator | IMenuItem | ICustomHTML;
+export interface IMenuItem extends IItem, IHtmlExtendable {
+    type?: "menuItem";
+    $openIcon?: string;
+    icon?: string;
+    items?: IMenuElement[];
+    hotkey?: string;
+    count?: number | string;
+    countColor?: "danger" | "secondary" | "primary" | "success";
+    value?: string;
+}
+export interface IPopup {
+    data: any[];
+    mode: "bottom" | "other";
+    position: any;
+    width: number;
+    height: number;
+}
+export interface INavItem extends IItem, IHtmlExtendable {
+    type: "navItem";
+    twoState?: boolean;
+    group?: string;
+    $openIcon?: string;
+    icon?: string;
+    items?: IMenuElement[];
+    value?: string;
+    hotkey?: string;
+    active?: boolean;
+    count?: number | string;
+    countColor?: "danger" | "secondary" | "primary" | "success";
+}
+export interface ICustomHTML extends IItem, IHtmlExtendable {
+    type: "customHTML";
+}
+export interface ITitle extends IItem, IHtmlExtendable {
+    type: "title";
+    value?: string;
+    tooltip?: string;
+}
+export interface ISpacer extends IItem {
+    type: "spacer";
+}
+export interface ISeparator extends IItem {
+    type: "separator";
+}
+export interface IButton extends IItem, IHtmlExtendable {
+    type: "button";
+    css?: string;
+    hotkey?: string;
+    tooltip?: string;
+    count?: number;
+    countColor?: "danger" | "secondary" | "primary" | "success";
+    items?: IMenuElement[];
+    group?: string;
+    twoState?: boolean;
+    active?: boolean;
+    multiClick?: boolean;
+    icon?: string;
+    view?: "flat" | "link";
+    size?: "small" | "medium" | string;
+    color?: "danger" | "secondary" | "primary" | "success";
+    full?: boolean;
+    circle?: boolean;
+    loading?: boolean;
+    value?: string;
+}
+export interface IInput extends IItem {
+    type: "input";
+    icon?: string;
+    placeholder?: string;
+    width?: string;
+    label?: string;
+    hiddenLabel?: boolean;
+    value?: string;
+    autocomplete?: boolean;
+}
+export interface IImageButton extends IItem {
+    type: "imageButton";
+    src: string;
+    twoState?: boolean;
+    active?: boolean;
+    hotkey?: string;
+    group?: string;
+    count?: number | string;
+    countColor?: "danger" | "secondary" | "primary" | "success";
+}
+export interface ISelectButton extends IItem {
+    type: "selectButton";
+    $openIcon?: string;
+    icon?: string;
+    items?: IMenuElement[];
+    count?: number | string;
+    countColor?: "danger" | "secondary" | "primary" | "success";
+    value?: string;
+}
+export interface ICustomHTMLButton extends IItem {
+    type: "customHTMLButton";
+    twoState?: boolean;
+    active?: boolean;
+    value?: string;
+    count?: number;
+    countColor?: "danger" | "secondary" | "primary" | "success";
+}
+export interface IBlock extends IItem {
+    type: "block";
+    title?: string;
+    direction?: "row" | "col";
+    css?: "string";
+}
+export interface IDatePicker extends IItem {
+    type: "datePicker";
+    icon?: string;
+    placeholder?: string;
+    width?: string;
+    label?: string;
+    hiddenLabel?: boolean;
+    editable?: boolean;
+    value?: string | Date;
+    dateFormat?: string;
+    valueFormat?: "string" | "date";
+    date?: Date | string;
+    mark?: (a: Date) => string;
+    disabledDates?: (a: Date) => boolean;
+    weekStart?: "saturday" | "sunday" | "monday";
+    weekNumbers?: boolean;
+    mode?: ViewMode;
+    timePicker?: boolean;
+    timeFormat?: 24 | 12;
+    thisMonthOnly?: boolean;
+    $calendar?: Calendar;
+    $popup?: Popup;
+}
+export declare enum NavigationBarEvents {
+    inputCreated = "inputCreated",
+    click = "click",
+    openMenu = "openMenu",
+    beforeHide = "beforeHide",
+    afterHide = "afterHide",
+    inputFocus = "inputFocus",
+    inputBlur = "inputBlur",
+    inputChange = "inputChange",
+    input = "input",
+    keydown = "keydown"
+}
+export interface INavbarEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [NavigationBarEvents.inputCreated]: (id: Id, input: HTMLInputElement) => void;
+    [NavigationBarEvents.openMenu]: (id: Id) => void;
+    [NavigationBarEvents.click]: (id: Id, events: Event) => void;
+    [NavigationBarEvents.beforeHide]: (id: Id, events: Event) => void | boolean;
+    [NavigationBarEvents.afterHide]: (events: Event) => void;
+    [NavigationBarEvents.inputBlur]: (id: Id) => void;
+    [NavigationBarEvents.inputFocus]: (id: Id) => void;
+    [NavigationBarEvents.inputChange]: (id: Id, newValue: string) => void;
+    [NavigationBarEvents.input]: (id: Id, value: string) => void;
+    [NavigationBarEvents.keydown]: (event: KeyboardEvent, id?: Id) => void;
+}

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

@@ -0,0 +1,2 @@
+export * from "./sources/Popup";
+export * from "./sources/types";

package/codebase/types/ts-popup/sources/Popup.d.ts

@@ -0,0 +1,29 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { IPopup, IPopupConfig, IPopupEventHandlersMap, IShowConfig, PopupEvents } from "./types";
+export declare class Popup extends View implements IPopup {
+    config: IPopupConfig;
+    events: IEventSystem<PopupEvents, IPopupEventHandlersMap>;
+    private _html;
+    private _ui;
+    private _popup;
+    private _clickEvent;
+    private _isActive;
+    private _outerClickDestructor;
+    private _timeout;
+    constructor(config?: IPopupConfig);
+    show(node: HTMLElement, config?: IShowConfig, attached?: any): void;
+    hide(): void;
+    isVisible(): boolean;
+    attach(name: any, config?: any): VNode;
+    attachHTML(html: string): void;
+    getWidget(): any;
+    getContainer(): HTMLElement;
+    toVDOM(): any;
+    destructor(): void;
+    private _setTheme;
+    private _setPopupSize;
+    private _detectOuterClick;
+    private _hide;
+}

package/codebase/types/ts-popup/sources/types.d.ts

@@ -0,0 +1,42 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { Position } from "../../ts-common/html";
+export interface IPopup {
+    show(node: HTMLElement, config?: IShowConfig, attach?: any): void;
+    hide(): void;
+    toVDOM(): void;
+    attachHTML(html: string): void;
+    attach(node: HTMLElement, config?: IShowConfig, attached?: any): VNode;
+    isVisible(): boolean;
+    paint(): void;
+    destructor(): void;
+    getWidget(): any;
+    getContainer(): HTMLElement;
+}
+export interface IPopupConfig {
+    css?: string;
+    events?: IEventSystem<any>;
+    theme?: HTMLElement | string;
+}
+export declare enum PopupEvents {
+    beforeHide = "beforeHide",
+    beforeShow = "beforeShow",
+    afterHide = "afterHide",
+    afterShow = "afterShow",
+    click = "click"
+}
+export interface IShowConfig {
+    centering?: boolean;
+    auto?: boolean;
+    mode?: Position;
+    indent?: number | string;
+    theme?: string | HTMLElement;
+}
+export interface IPopupEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [PopupEvents.click]: (e: Event) => any;
+    [PopupEvents.afterHide]: (e: Event) => void;
+    [PopupEvents.afterShow]: (node: HTMLElement) => void;
+    [PopupEvents.beforeHide]: (fromOuterClick: boolean, e: Event) => void | boolean;
+    [PopupEvents.beforeShow]: (node: HTMLElement) => void | boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from "./sources/Slider";
+export * from "./sources/types";

package/codebase/types/ts-slider/sources/Slider.d.ts

@@ -0,0 +1,55 @@
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { Popup } from "../../ts-popup";
+import { ISlider, SliderEvents, ISliderConfig, ISliderEventHandlersMap } from "./types";
+export declare class Slider extends View implements ISlider {
+    config: ISliderConfig;
+    events: IEventSystem<SliderEvents, ISliderEventHandlersMap>;
+    protected _helper: Popup;
+    private _offsets;
+    private _currentPosition;
+    private _extraCurrentPosition;
+    private _length;
+    private _axis;
+    private _isExtraActive;
+    private _disabled;
+    private _isMouseMoving;
+    private _keyManager;
+    private _handlers;
+    private _possibleRange;
+    private _findNewDirection;
+    private _mouseIn;
+    private _focusIn;
+    private _tooltip;
+    private _activeTooltip;
+    constructor(container: HTMLElement | string, config: ISliderConfig);
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    focus(extra?: boolean): void;
+    blur(): void;
+    getValue(): number[];
+    setValue(value: string | number | number[]): void;
+    destructor(): void;
+    private _calcSliderPosition;
+    private _initHotkeys;
+    private _move;
+    private _initStartPosition;
+    private _getValue;
+    private _setValue;
+    private _initHandlers;
+    private _getBegining;
+    private _inSide;
+    private _updatePosition;
+    private _getRunnerStyle;
+    private _isInverse;
+    private _getRunnerCss;
+    private _draw;
+    private _drawSlider;
+    private _getDetector;
+    private _drawTooltip;
+    private _getTicks;
+    private _drawTicks;
+    private _isNullable;
+    private _setTooltip;
+}

package/codebase/types/ts-slider/sources/types.d.ts

@@ -0,0 +1,60 @@
+export type Direction = "vertical" | "horizontal";
+export type ActiveSlider = "tooltip" | "extraTooltip" | "none";
+export interface ISlider {
+    config: ISliderConfig;
+    paint(): void;
+    destructor(): void;
+    getValue(): number[];
+    setValue(value: string | number | number[]): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    focus(extra?: boolean): void;
+    blur(): void;
+}
+export declare enum SliderEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    focus = "focus",
+    blur = "blur",
+    keydown = "keydown",
+    mousedown = "mousedown",
+    mouseup = "mouseup"
+}
+export interface ISliderEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [SliderEvents.beforeChange]: (value: number, oldValue: number, isRange: boolean) => void;
+    [SliderEvents.change]: (value: number, oldValue: number, isRange: boolean) => void;
+    [SliderEvents.focus]: () => void;
+    [SliderEvents.blur]: () => void;
+    [SliderEvents.keydown]: (event: KeyboardEvent) => void;
+    [SliderEvents.mousedown]: (event: Event) => void;
+    [SliderEvents.mouseup]: (event: Event) => void;
+}
+export type ILabelPosition = "left" | "top";
+export interface ISliderConfig {
+    min?: number;
+    max?: number;
+    step?: number;
+    mode?: Direction;
+    range?: boolean;
+    value?: number[] | number | string;
+    inverse?: boolean;
+    tooltip?: boolean;
+    css?: string;
+    tick?: number;
+    tickTemplate?: (position: number) => string;
+    majorTick?: number;
+    label?: string;
+    required?: boolean;
+    helpMessage?: string;
+    labelPosition?: ILabelPosition;
+    labelWidth?: string | number;
+    hiddenLabel?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    help?: string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    thumbLabel?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    labelInline?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from "./sources/Timepicker";
+export * from "./sources/types";

package/codebase/types/ts-timepicker/sources/Timepicker.d.ts

@@ -0,0 +1,28 @@
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { Layout } from "../../ts-layout";
+import { TimepickerEvents, ITimepickerConfig, ITimepicker, ITimeObject, ITimepickerHandlersMap } from "./types";
+export declare class Timepicker extends View implements ITimepicker {
+    config: ITimepickerConfig;
+    events: IEventSystem<TimepickerEvents, ITimepickerHandlersMap>;
+    layout: Layout;
+    private _hoursSlider;
+    private _minutesSlider;
+    private _inputsView;
+    private _time;
+    private _handlers;
+    private _outerHandlers;
+    constructor(container: HTMLElement | string, config?: ITimepickerConfig);
+    getValue<T extends boolean = false>(asObject?: T): T extends true ? ITimeObject : string;
+    setValue(value: Date | number | string | any[] | ITimeObject): void;
+    clear(): void;
+    destructor(): void;
+    getRootView(): any;
+    private _getValue;
+    private _setValue;
+    private _initUI;
+    private _initHandlers;
+    private _initEvents;
+    private _draw;
+    private _isTimeObj;
+}

package/codebase/types/ts-timepicker/sources/helper.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function is designed to resolve conflicts with the time setting for the 12 hour format.
+ */
+export declare function isTimeCheck(value: any): boolean;

package/codebase/types/ts-timepicker/sources/locales/en.d.ts

@@ -0,0 +1,6 @@
+declare const locale: {
+    hours: string;
+    minutes: string;
+    save: string;
+};
+export default locale;

package/codebase/types/ts-timepicker/sources/types.d.ts

@@ -0,0 +1,52 @@
+import { IEventSystem } from "../../ts-common/events";
+import { Layout } from "../../ts-layout";
+export interface ITimepickerConfig {
+    css?: string;
+    timeFormat?: 12 | 24;
+    controls?: boolean;
+    value?: Date | number | string | any[] | ITimeObject;
+    valueFormat?: "string" | "timeObject";
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    actions?: boolean;
+}
+export interface ITimepicker {
+    config: ITimepickerConfig;
+    events: IEventSystem<TimepickerEvents, ITimepickerHandlersMap>;
+    layout: Layout;
+    paint(): void;
+    getValue(asOBject?: boolean): ITimeObject | string;
+    setValue(value: Date | number | string | any[] | ITimeObject): void;
+    clear(): void;
+    destructor(): void;
+}
+export interface ITimeObject {
+    hour: number;
+    minute: number;
+    AM?: boolean;
+}
+export declare enum TimepickerEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    beforeApply = "beforeApply",
+    afterApply = "afterApply",
+    beforeClose = "beforeClose",
+    afterClose = "afterClose",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    apply = "apply",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close = "close",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    save = "save"
+}
+export interface ITimepickerHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [TimepickerEvents.beforeChange]: (value: string | ITimeObject) => boolean | void;
+    [TimepickerEvents.change]: (value: string | ITimeObject) => void;
+    [TimepickerEvents.beforeApply]: (value: string | ITimeObject) => boolean | void;
+    [TimepickerEvents.afterApply]: (value: string | ITimeObject) => void;
+    [TimepickerEvents.beforeClose]: (value: string | ITimeObject) => boolean | void;
+    [TimepickerEvents.afterClose]: (value: string | ITimeObject) => void;
+    [TimepickerEvents.apply]: (value: string) => void;
+    [TimepickerEvents.close]: () => any;
+    [TimepickerEvents.save]: (value?: ITimeObject) => any;
+}

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

@@ -0,0 +1,2 @@
+export * from "./sources/Toolbar";
+export * from "./sources/ProToolbar";

package/codebase/types/ts-toolbar/sources/ProToolbar.d.ts

@@ -0,0 +1,10 @@
+import { Toolbar, IToolbar } from "./Toolbar";
+import { ScrollView } from "../../ts-common/ScrollView";
+export interface IProToolbar extends IToolbar {
+    scrollView: ScrollView;
+}
+export declare class ProToolbar extends Toolbar implements IProToolbar {
+    scrollView: ScrollView;
+    constructor(element?: string | HTMLElement, config?: any);
+    protected _draw(element: any): any;
+}

package/codebase/types/ts-toolbar/sources/Toolbar.d.ts

@@ -0,0 +1,33 @@
+import { Id } from "../../ts-common/types";
+import { TreeCollection } from "../../ts-data";
+import { IState, Navbar, INavbar, IButton, IImageButton, ISelectButton, IInput, ISeparator, ISpacer, ITitle, ICustomHTML, INavItem, IMenuItem, IDatePicker, NavigationType } from "../../ts-navbar";
+export interface IToolbarConfig {
+    css?: string;
+    menuCss?: string;
+    data?: any[] | TreeCollection<IToolbarElement>;
+    navigationType?: NavigationType;
+}
+export interface IToolbar extends INavbar {
+    data: TreeCollection<IToolbarElement>;
+    config: IToolbarConfig;
+    getState(id?: Id): IState;
+    setState(state: IState): void;
+}
+export type IToolbarElement = IButton | IImageButton | ISelectButton | IInput | ISeparator | ISpacer | ITitle | ICustomHTML | INavItem | IMenuItem | IDatePicker;
+export declare class Toolbar extends Navbar<IToolbarElement> implements IToolbar {
+    data: TreeCollection<IToolbarElement>;
+    config: IToolbarConfig;
+    constructor(element?: string | HTMLElement, config?: any);
+    getState(id?: Id): IState;
+    setState(state: IState): void;
+    setFocus(id: Id): void;
+    protected _customHandlers(): {
+        input: (e: Event) => void;
+        tooltip: (e: MouseEvent) => void;
+    };
+    protected _getFactory(): any;
+    protected _draw(element: any): any;
+    protected _getMode(item: any, root: any): "right" | "bottom";
+    protected _close(e: MouseEvent): void;
+    protected _setRoot(id: Id): void;
+}

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

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

package/codebase/types/ts-treegrid/sources/TreeGrid.d.ts

@@ -0,0 +1,26 @@
+import { GridEvents, IEventHandlersMap, ExtendedGrid, ICellRect, IColumnsWidth, ISpan, IAdjustColumns } from "../../ts-grid";
+import { IEventSystem } from "../../ts-common/events";
+import { DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap } from "../../ts-data";
+import { TreeGridCollection } from "./TreeGridCollection";
+import { ITreeGrid, ITreeGridConfig } from "./types";
+import { Id } from "../../ts-common/types";
+export declare class TreeGrid extends ExtendedGrid implements ITreeGrid {
+    config: ITreeGridConfig;
+    data: TreeGridCollection;
+    events: IEventSystem<DataEvents | GridEvents | DragEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap>;
+    constructor(container: HTMLElement | string | null, config: ITreeGridConfig);
+    expand(rowId: Id): void;
+    collapse(rowId: Id): void;
+    expandAll(): void;
+    collapseAll(): void;
+    showRow(rowId: Id): void;
+    hideRow(rowId: Id): void;
+    getCellRect(rowId: Id, colId?: Id): ICellRect;
+    getSpan(rowId: Id, colId: Id): ISpan;
+    protected _adjustColumnsWidth({ rows, cols, totalCols, adjust, }: IAdjustColumns): IColumnsWidth;
+    protected _createCollection(): void;
+    protected _getRowIndex(rowId: Id): number;
+    protected _applyLocalFilter(beforePrepareData?: boolean): void;
+    protected _setEventHandlers(): void;
+    private _serialize;
+}

package/codebase/types/ts-treegrid/sources/TreeGridCollection.d.ts

@@ -0,0 +1,21 @@
+import { IEventSystem } from "../../ts-common/events";
+import { DataCallback, DataDriver, DataEvents, IDataItem, TreeCollection } from "../../ts-data";
+import { Id } from "../../ts-common/types";
+import { GridEvents } from "../../ts-grid";
+export declare class TreeGridCollection extends TreeCollection {
+    constructor(config?: any, events?: IEventSystem<DataEvents | GridEvents>);
+    eachChild(id: Id, cb: any, direct?: boolean, checkItem?: (item: IDataItem) => boolean): void;
+    getMaxLevel(): number;
+    getLevel(id: Id): number;
+    serialize(driver?: DataDriver): any[];
+    getPlainIndex(id: Id): number;
+    map(cb: DataCallback<IDataItem>, parent?: Id, direct?: boolean): IDataItem[];
+    mapVisible(cb: DataCallback<IDataItem>, parent?: Id, direct?: boolean): IDataItem[];
+    protected _parse_data(data: any, parent?: Id): void;
+    protected _copy(id: Id, index: number, target?: TreeGridCollection, targetId?: Id, key?: number): Id;
+    protected _addToOrder(_order: any, obj: any, index: number): void;
+    protected _removeCore(id: Id): void;
+    protected _setParent(item: IDataItem, parent: Id): void;
+    private _checkItems;
+    protected _moveItem(id: any, targetId: any, index: any): void;
+}

package/codebase/types/ts-treegrid/sources/types.d.ts

@@ -0,0 +1,17 @@
+import { DataEvents, DragEvents, DropBehaviour, IDataEventsHandlersMap, IDragEventsHandlersMap } from "../../ts-data";
+import { GridEvents, IEventHandlersMap, IExtendedGrid, IExtendedGridConfig } from "../../ts-grid";
+import { IEventSystem } from "../../ts-common/events";
+import { Id } from "../../ts-common/types";
+import { TreeGridCollection } from "./TreeGridCollection";
+export interface ITreeGridConfig extends IExtendedGridConfig {
+    type?: "tree";
+    rootParent?: Id;
+    collapsed?: boolean;
+    dragExpand?: boolean;
+    dropBehaviour?: DropBehaviour;
+}
+export interface ITreeGrid extends IExtendedGrid {
+    events: IEventSystem<DataEvents | GridEvents | DragEvents, IEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap>;
+    config: ITreeGridConfig;
+    data: TreeGridCollection;
+}

package/codebase/types/ts-vault/sources/ProgressBar.d.ts

@@ -0,0 +1,12 @@
+import { View } from "../../ts-common/view";
+import { IProgressBarConfig, IVaultEventSystem } from "./types";
+export declare class ProgressBar<T> extends View {
+    config: IProgressBarConfig<T>;
+    events: IVaultEventSystem;
+    private _progress;
+    private _progressText;
+    private _abortUpload;
+    constructor(events: IVaultEventSystem, config: IProgressBarConfig<T>);
+    setState(progress: number, extra: T): void;
+    private _draw;
+}

package/codebase/types/ts-vault/sources/ReadStackPreview.d.ts

@@ -0,0 +1,11 @@
+import { DataCollection } from "../../ts-data";
+import { IFileWrapper } from "./types";
+export declare class ReadStackPreview {
+    private _data;
+    private _readerStack;
+    private _isActive;
+    constructor(data: DataCollection<IFileWrapper>);
+    add(fileWrapper: IFileWrapper, wait?: boolean): void;
+    read(): void;
+    stop(): void;
+}