@dhtmlx/vault 5.0.6

package/codebase/types/ts-common/core.d.ts

@@ -0,0 +1,40 @@
+type fn<T extends any[], K> = (...args: T) => K;
+type anyFunction = fn<any[], any>;
+export declare function uid(): string;
+export declare function extendComponent(target: any, source: any): any;
+export declare function extend(target: any, source: any, deep?: boolean): any;
+interface IOBj {
+    [key: string]: any;
+}
+export declare function copy(source: IOBj, withoutInner?: boolean): IOBj;
+export declare function naturalSort(arr: any): any[];
+export declare function findIndex<T = any>(arr: T[], predicate: (obj: T) => boolean): number;
+export declare function isExistValue(target: number | string, value: number | string): boolean;
+export declare function singleOuterClick(fn: (e: MouseEvent) => boolean): void;
+export declare function detectWidgetClick(widgetId: string, cb: (inner: boolean) => void): () => void;
+export declare function unwrapBox<T>(box: T | T[]): T;
+export declare function wrapBox<T>(unboxed: T | T[]): T[];
+export declare function isDefined<T>(some: T): boolean;
+export declare function isId<T>(some: T): boolean;
+export declare function range(from: number, to: number): number[];
+export declare function isNumeric(val: any): boolean;
+export declare function downloadFile(data: Blob | string, filename: string, mimeType?: string): void;
+export declare function debounce(func: anyFunction, wait: number, immediate?: boolean): (...args: any[]) => void;
+export declare function compare(obj1: any, obj2: any): boolean;
+export declare const isType: (value: any) => string;
+export declare const isEmptyObj: (obj: any) => boolean;
+export declare const getMaxArrayNumber: (array: number[]) => number;
+export declare const getMinArrayNumber: (array: number[]) => number;
+export interface IContainerConfig {
+    lineHeight?: number;
+    font?: string;
+}
+export declare const getStringWidth: (value: string, config?: IContainerConfig) => number;
+export declare const rgbToHex: (color: string) => string;
+export declare function getCloneObject(obj: any): any;
+export declare function getTextLines({ ctx, text, maxWidth }: {
+    ctx: any;
+    text: any;
+    maxWidth: any;
+}): string[];
+export {};

package/codebase/types/ts-common/date.d.ts

@@ -0,0 +1,34 @@
+export declare const locale: {
+    monthsShort: string[];
+    months: string[];
+    daysShort: string[];
+    days: string[];
+    cancel: string;
+};
+export declare function getFormattedDate(format: string, date: Date): string;
+export declare function getExcelDate(date: Date): number;
+export declare function stringToDate(str: string, format: string, validate?: boolean): any;
+export declare class DateHelper {
+    static nullTimestampDate: Date;
+    static copy(d: Date): Date;
+    static fromYear(year: number): Date;
+    static fromYearAndMonth(year: number, month: number): Date;
+    static weekStart(d: Date, firstWeekday: -1 | 0 | 1): Date;
+    static monthStart(d: Date): Date;
+    static yearStart(d: Date): Date;
+    static dayStart(d: Date): Date;
+    static addDay(d: Date, count?: number): Date;
+    static addMonth(d: Date, count?: number): Date;
+    static addYear(d: Date, count?: number): Date;
+    static withHoursAndMinutes(d: Date, hours: number, minutes: number, dateFormat: boolean): Date;
+    static setMonth(d: Date, month: number): void;
+    static setYear(d: Date, year: number): void;
+    static mergeHoursAndMinutes(source: Date, target: Date): Date;
+    static isWeekEnd(d: Date): boolean;
+    static getTwelweYears(d: Date): number[];
+    static getDayOrdinal(d: Date): number;
+    static getWeekNumber(d: Date): number;
+    static isSameDay(d1: Date, d2: Date): boolean;
+    static toDateObject(date: Date | string, dateFormat: string): Date;
+}
+export declare function stripTime(d: Date, full?: boolean): Date;

package/codebase/types/ts-common/dom.d.ts

@@ -0,0 +1,24 @@
+import { TTheme } from "./types";
+export declare const el: any;
+export declare const sv: any;
+export declare const view: any;
+export declare const create: any;
+export declare const inject: any;
+export declare const KEYED_LIST: any;
+export declare function disableHelp(): void;
+export type VNode = any;
+export interface IDomView {
+    redraw(): any;
+    mount(el: HTMLElement): any;
+}
+export interface IDomRender {
+    render(view: IDomView, data: any): VNode;
+}
+export interface IViewHash {
+    [name: string]: IDomRender;
+}
+export declare function resizer(handler: any): any;
+export declare function resizeHandler(container: any, handler: any): any;
+export declare function awaitRedraw(): Promise<void>;
+export declare function setTheme(theme: TTheme, container: string | HTMLElement): void;
+export declare function getViewHeight(view: VNode, width: number): number;

package/codebase/types/ts-common/events.d.ts

@@ -0,0 +1,35 @@
+export type Callback = (...args: any[]) => any;
+export interface IEventSystem<E, T extends IEventHandlersMap = IEventHandlersMap> {
+    context: any;
+    events: IEvents;
+    on<K extends keyof T>(name: K, callback: T[K], context?: any): any;
+    detach(name: E, context?: any): any;
+    clear(): void;
+    fire<K extends keyof T>(name: K, args?: ArgumentTypes<T[K]>): boolean;
+}
+interface IEvent {
+    callback: Callback;
+    context: any;
+}
+interface IEvents {
+    [key: string]: IEvent[];
+}
+interface IEventHandlersMap {
+    [key: string]: Callback;
+}
+type ArgumentTypes<F extends (...args: any[]) => any> = F extends (...args: infer A) => any ? A : never;
+export declare class EventSystem<E extends string, T extends IEventHandlersMap = IEventHandlersMap> implements IEventSystem<E, T> {
+    events: IEvents;
+    context: any;
+    constructor(context?: any);
+    on<K extends keyof T>(name: K, callback: T[K], context?: any): void;
+    detach(name: E, context?: any): void;
+    fire<K extends keyof T>(name: K, args: ArgumentTypes<T[K]>): boolean;
+    clear(): void;
+}
+export declare function EventsMixin(obj: any): void;
+export interface IEventFacade {
+    attachEvent: any;
+    callEvent: any;
+}
+export {};

package/codebase/types/ts-common/html.d.ts

@@ -0,0 +1,74 @@
+import { anyFunction } from "./types";
+export declare function toNode(node: string | HTMLElement): HTMLElement;
+type eventPrepare = (ev: Event) => any;
+interface IHandlerHash {
+    [name: string]: (...args: any[]) => boolean | void;
+}
+export declare function eventHandler(prepare: eventPrepare, hash: IHandlerHash, afterCall?: anyFunction): (ev: Event) => boolean;
+export declare function locateNode(target: Event | Element, attr?: string, dir?: string): Element;
+export declare function locate(target: Event | Element, attr?: string): string;
+export declare function locateNodeByClassName(target: Event | Element, className?: string): Element;
+export declare function getBox(elem: any): {
+    top: any;
+    left: any;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+export declare function getScrollbarWidth(): number;
+export declare function getScrollbarHeight(): number;
+export interface IFitTarget {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface IFitPosition {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface IFitPositionConfig {
+    mode?: Position;
+    auto?: boolean;
+    centering?: boolean;
+    width: number;
+    height: number;
+}
+export type IAlign = "left" | "center" | "right";
+export type Position = "left" | "right" | "bottom" | "top";
+export type FlexDirection = "start" | "center" | "end" | "between" | "around" | "evenly";
+export declare function isIE(): boolean;
+export declare function isSafari(): any;
+export declare function isFirefox(): any;
+export declare function getRealPosition(node: HTMLElement): IFitPosition;
+export declare function calculatePosition(pos: IFitPosition, config: IFitPositionConfig): {
+    left: string;
+    top: string;
+    minWidth: string;
+    position: string;
+};
+export declare function fitPosition(node: HTMLElement, config: IFitPositionConfig): {
+    left: string;
+    top: string;
+    minWidth: string;
+    position: string;
+};
+export declare function getPageCss(): string;
+export declare function getLabelStyle(config: any): false | {
+    style: {
+        width: any;
+        "max-width": string;
+    };
+    label: any;
+};
+export declare function getPageInlineCss(): string;
+export declare function getPageLinksCss(exportStyles?: string[]): string;
+export declare function getElementFromPoint(e: MouseEvent | TouchEvent): Element | null;
+export declare function getNodeOffset(node1: HTMLElement, node2: HTMLElement): {
+    left: number;
+    top: number;
+};
+export {};

package/codebase/types/ts-common/input.d.ts

@@ -0,0 +1,24 @@
+export interface INumberMask {
+    prefix?: string;
+    suffix?: string;
+    groupSeparator?: string;
+    decSeparator?: string;
+    allowNegative?: boolean;
+    maxIntLength?: number;
+    maxDecLength?: number;
+    minDecLength?: number;
+}
+export interface INumberMaskConfig extends INumberMask {
+    onlyView?: boolean;
+    lastCall?: boolean;
+}
+export declare function numberMask(value: string | number, options: INumberMaskConfig, input?: HTMLInputElement): string | number;
+export declare function removeNumberMask(value: string, options: INumberMaskConfig): string;
+export interface IPatternMask {
+    pattern: ((value: string | number) => string) | string;
+    charFormat?: {
+        [char: string]: RegExp;
+    };
+}
+export declare function patternMask(value: string | number, options: IPatternMask | string, input?: HTMLInputElement): string;
+export declare function removePatternMask(value: string, options: IPatternMask | string): string;

package/codebase/types/ts-common/keycodes.d.ts

@@ -0,0 +1,9 @@
+export declare const KEY_CODES: {
+    BACKSPACE: number;
+    ENTER: number;
+    ESC: number;
+    DOWN_ARROW: number;
+    UP_ARROW: number;
+    LEFT_ARROW: number;
+    RIGHT_ARROW: number;
+};

package/codebase/types/ts-common/locale.d.ts

@@ -0,0 +1 @@
+export declare function setLocale(component: string, value: any): void;

package/codebase/types/ts-common/types.d.ts

@@ -0,0 +1,76 @@
+import { IEventSystem } from "./events";
+export interface IHandlers {
+    [key: string]: anyFunction | IHandlers;
+}
+export type TTheme = "light" | "dark" | "contrast-light" | "contrast-dark" | string;
+export type Id = string | number;
+export type fn<T extends any[], K> = (...args: T) => K;
+export type anyFunction = fn<any[], any>;
+export interface IAnyObj {
+    [key: string]: any;
+}
+export interface ISelectionConfig {
+    disabled?: boolean;
+}
+export interface ISelection {
+    events: IEventSystem<SelectionEvents>;
+    config: ISelectionConfig;
+    getId(): Id;
+    getItem(): any;
+    add(id: Id): void;
+    remove(id?: Id): boolean;
+    enable(): void;
+    disable(): void;
+}
+export declare enum SelectionEvents {
+    beforeUnSelect = "beforeunselect",
+    afterUnSelect = "afterunselect",
+    beforeSelect = "beforeselect",
+    afterSelect = "afterselect"
+}
+export interface ISelectionEventsHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [SelectionEvents.afterSelect]: (id: Id) => void;
+    [SelectionEvents.afterUnSelect]: (id: Id) => void;
+    [SelectionEvents.beforeSelect]: (id: Id) => void | boolean;
+    [SelectionEvents.beforeUnSelect]: (id: Id) => void | boolean;
+}
+export interface ITouchParam {
+    duration?: number;
+    timer?: any;
+    start?: boolean;
+    timeStamp?: number;
+    dblDuration?: number;
+}
+export type TExportType = "pdf" | "png";
+export type TPaperFormat = "Letter" | "Legal" | "Tabloid" | "Ledger" | "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A6";
+export interface IExportFileConfig {
+    url?: string;
+    name?: string;
+    header?: string;
+    footer?: string;
+    exportStyles?: boolean | string[];
+    theme?: string;
+}
+export interface IPDFConfig extends IExportFileConfig {
+    pdf?: {
+        scale?: number;
+        landscape?: boolean;
+        format?: TPaperFormat;
+        margin?: {
+            top?: string | number;
+            right?: string | number;
+            bottom?: string | number;
+            left?: string | number;
+        };
+        width?: string;
+        height?: string;
+        pageRanges?: string;
+        displayHeaderFooter?: boolean;
+        footerTemplate?: string;
+        headerTemplate?: string;
+        printBackground?: boolean;
+    };
+}
+export type IPNGConfig = IExportFileConfig;
+export type TLabelAlignment = "left" | "right" | "center";

package/codebase/types/ts-common/view.d.ts

@@ -0,0 +1,27 @@
+export interface IView {
+    getRootView(): any;
+    paint(): void;
+    mount(container: any, vnode?: any): void;
+}
+export interface IViewLike {
+    mount?(container: any, vnode?: any): void;
+    getRootView(): any;
+}
+export declare class View {
+    config: any;
+    protected _container: any;
+    protected _uid: any;
+    protected _doNotRepaint: boolean;
+    private _view;
+    constructor(_container: any, config: any);
+    mount(container: any, vnode?: any): void;
+    unmount(): void;
+    getRootView(): any;
+    getRootNode(): HTMLElement;
+    paint(): void;
+}
+export declare function toViewLike(view: any): {
+    getRootView: () => any;
+    paint: () => any;
+    mount: (container: any) => any;
+};

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

@@ -0,0 +1,13 @@
+export * from "./sources/types";
+export * from "./sources/datacollection";
+export * from "./sources/treecollection";
+export * from "./sources/DragManager";
+export * from "./sources/dataproxy";
+export * from "./sources/lazydataproxy";
+export * from "./sources/helpers";
+export * from "./sources/drivers/CsvDriver";
+export * from "./sources/drivers/JsonDriver";
+export * from "./sources/selection";
+export * from "./sources/drivers/drivers";
+export * from "./sources/ajax";
+export * from "./sources/methods";

package/codebase/types/ts-data/sources/CollectionStore.d.ts

@@ -0,0 +1,7 @@
+import { Id } from "../../ts-common/types";
+export declare class CollectionStore {
+    private _store;
+    setItem(id: Id, target: any): void;
+    getItem(id: Id): any;
+}
+export declare const collectionStore: any;

package/codebase/types/ts-data/sources/DragManager.d.ts

@@ -0,0 +1,19 @@
+import { Id } from "../../ts-common/types";
+export type TDragItem = "row" | "group" | "column";
+interface IDragConfig {
+    event: MouseEvent | TouchEvent;
+    type: TDragItem;
+    source?: Id[];
+    itemsForGhost?: NodeList | HTMLDivElement[] | Element[];
+    ghost?: HTMLElement;
+    groupable?: boolean;
+    groupOnly?: boolean;
+}
+export interface IDragManager {
+    setItem(id: Id, item: any): void;
+    onMouseDown(config: IDragConfig): void;
+    isDrag(): boolean;
+    cancelCanDrop(event: MouseEvent | TouchEvent): void;
+}
+export declare const dragManager: IDragManager;
+export {};

package/codebase/types/ts-data/sources/ajax.d.ts

@@ -0,0 +1,2 @@
+import { IAjaxHelper } from "./types";
+export declare const ajax: IAjaxHelper;

package/codebase/types/ts-data/sources/datacollection/group.d.ts

@@ -0,0 +1,43 @@
+import { IDataItem } from "../types";
+export type TGroupOrderFunc = (i: IDataItem) => string;
+export type TAggregate = "sum" | "count" | "min" | "max" | "avg" | string;
+export interface IGroupOrder {
+    by: string | TGroupOrderFunc;
+    map?: {
+        [field: string]: [string, TAggregate] | ((i: IDataItem[]) => string | number);
+    };
+    summary?: "top" | "bottom";
+}
+export interface IGroupOrderConfig extends IGroupOrder {
+    by: string;
+}
+export type TGroupOrder = string | TGroupOrderFunc | IGroupOrder;
+export type TDisplayMode = "original" | "column" | "row";
+export interface IGroupConfig {
+    displayMode?: TDisplayMode;
+    showMissed?: boolean | string;
+    field?: string;
+}
+export interface IGroup {
+    group(order: TGroupOrder[], arr: IDataItem[], config: IGroupConfig): IDataItem[];
+    ungroup(arr?: IDataItem[]): IDataItem[];
+    isGrouped(): boolean;
+    getGroupedFields(): string[];
+    getGroupConfig(config?: IGroupConfig): IGroupConfig;
+}
+export declare class Group implements IGroup {
+    private _init;
+    private _config;
+    private _groupSet;
+    private _groupOrderFields;
+    constructor();
+    group(order: TGroupOrder[], arr: IDataItem[], config?: IGroupConfig): IDataItem[];
+    ungroup(modifiedData?: IDataItem[]): IDataItem[];
+    isGrouped(): boolean;
+    getGroupedFields(): string[];
+    getGroupConfig(config?: IGroupConfig): IGroupConfig;
+    private _group;
+    private _addSummaryRow;
+    private _toAggregate;
+    private _getOrderConfig;
+}

package/codebase/types/ts-data/sources/datacollection/loader.d.ts

@@ -0,0 +1,16 @@
+import { IDataChangeStack, IDataDriver, IDataProxy, IDataCollection, DataDriver } from "../types";
+export declare class Loader {
+    private _parent;
+    private _saving;
+    private _changes;
+    constructor(parent: IDataCollection, changes: any);
+    load(url: IDataProxy, driver?: IDataDriver | DataDriver): Promise<any>;
+    parse(data: any | any[], driver?: IDataDriver | DataDriver): any;
+    save(url: IDataProxy): void;
+    updateChanges(changes: IDataChangeStack): void;
+    private _setPromise;
+    private _addToChain;
+    private _findPrevState;
+    private _removeFromOrder;
+    private _getUniqueOrder;
+}

package/codebase/types/ts-data/sources/datacollection/sort.d.ts

@@ -0,0 +1,7 @@
+import { ISortMode } from "../types";
+export declare class Sort {
+    sort(array: any[], sorters: ISortMode[]): any[];
+    private _createSorter;
+    private _checkVal;
+    private _sort;
+}

package/codebase/types/ts-data/sources/datacollection.d.ts

@@ -0,0 +1,101 @@
+import { IEventSystem } from "../../ts-common/events";
+import { Id } from "../../ts-common/types";
+import { Sort } from "./datacollection/sort";
+import { DataCallback, DataEvents, IDataCollection, IDataItem, IDataProxy, IFilterCallback, IFilterConfig, IFilterMode, ISortMode, ITreeCollection, IUpdateObject, ReduceCallBack, Statuses, IDataEventsHandlersMap, DataDriver, IDataConfig, ISortConfig, IDataDriver, IFilterComplexMode, IFilter, IResetFilterConfig, IGroupDataConfig, ISortingState } from "./types";
+import { TGroupOrder, IGroup } from "./datacollection/group";
+export declare class DataCollection<T extends IDataItem = IDataItem> implements IDataCollection<T> {
+    loadData: Promise<any>;
+    saveData: Promise<any>;
+    dataProxy: IDataProxy;
+    config: IDataConfig;
+    events: IEventSystem<DataEvents, IDataEventsHandlersMap>;
+    protected _order: T[];
+    protected _pull: {
+        [id: string]: T;
+    };
+    protected _sort: Sort;
+    protected _sorter: ISortMode;
+    protected _meta: any;
+    protected _range: [number, number];
+    protected _loaded: boolean;
+    protected _initFilterOrder: T[];
+    protected _initSortOrder: T[];
+    protected _filters: IFilter;
+    protected _group: IGroup;
+    protected _sortingStates: ISortingState[];
+    private _changes;
+    private _loader;
+    constructor(config?: any, events?: IEventSystem<any>);
+    protected _reset(config?: {
+        grouping?: boolean;
+    }): void;
+    group(order: TGroupOrder[], config?: IGroupDataConfig): void;
+    ungroup(): void;
+    isGrouped(): boolean;
+    add(newItem: IDataItem, index?: number): Id;
+    add(newItem: IDataItem[], index?: number): Id[];
+    remove(id: Id | Id[]): void;
+    removeAll(): void;
+    exists(id: Id): boolean;
+    getNearId(id: Id): Id;
+    getItem(id: Id): T;
+    update(id: Id, newItem: IUpdateObject, silent?: boolean): void;
+    getIndex(id: Id): number;
+    getId(index: number): Id;
+    getLength(): number;
+    isDataLoaded(from?: number, to?: number): boolean;
+    filter(rule?: IFilterMode | IFilterComplexMode | IFilterCallback, config?: IFilterConfig, silent?: boolean): string;
+    resetFilter(config?: IResetFilterConfig, silent?: boolean): boolean;
+    getFilters(config?: {
+        permanent?: boolean;
+    }): IFilter;
+    getRawFilters(config?: {
+        permanent?: boolean;
+    }): IFilter;
+    find(conf: IFilterMode | DataCallback<T>): any;
+    findAll(conf: IFilterMode | DataCallback<T>): any[];
+    sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
+    getSortingStates(): ISortMode[];
+    copy(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
+    move(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, newId?: Id): Id | Id[];
+    forEach(callback: DataCallback<T>): void;
+    load(url: IDataProxy | string, driver?: IDataDriver | DataDriver): Promise<any>;
+    parse(data: T[] | string, driver?: DataDriver | IDataDriver): any;
+    $parse(data: any[]): void;
+    save(url: IDataProxy | string): void;
+    changeId(id: Id, newId?: Id, silent?: boolean): void;
+    isSaved(): boolean;
+    map(callback: DataCallback<T>): any[];
+    mapRange(from: number, to: number, callback: DataCallback<T>): any[];
+    reduce<A>(callback: ReduceCallBack<T, A>, acc: A): A;
+    serialize(driver?: DataDriver): any;
+    getInitialData(): T[];
+    setMeta(obj: T, key: string, value: any): void;
+    getMeta(obj: T, key: string): any;
+    getMetaMap(obj: T): any;
+    setRange(from: number, to: number): void;
+    getRawData(from: number, to: number, order?: T[], mode?: number): T[];
+    protected _add({ newItem, index, order, batch, }: {
+        newItem: IDataItem;
+        batch: IDataItem[];
+        order?: number;
+        index?: number;
+    }): Id;
+    protected _remove(id: Id, batch: Id[], index?: number): void;
+    protected _copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number): Id;
+    protected _move(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number, newId?: Id): Id;
+    protected _addCore(obj: IDataItem, index?: number): Id;
+    protected _removeCore(id: Id): void;
+    protected _parse_data(data: any[]): void;
+    protected _approximate(data: any[], values: string[], maxNum: number): any[];
+    protected _onChange(status: Statuses, id: Id, obj: any): void;
+    protected _addToOrder(array: any[], obj: any, index?: number): void;
+    protected _applySorters(): void;
+    protected _applyFilters(rule?: IFilterMode | IFilterCallback): void;
+    protected _reapplyFilters(): void;
+    protected _getRuleCallback(rule: IFilterMode): IFilterCallback;
+    protected _getPureFilters(filters: IFilter): IFilter;
+    protected _normalizeFilters(filters: any): any;
+    protected _checkFilterRule(rule: IFilterMode | IFilterCallback): boolean;
+    private _parse;
+}

package/codebase/types/ts-data/sources/dataproxy.d.ts

@@ -0,0 +1,10 @@
+import { IDataProxy } from "./types";
+export declare class DataProxy implements IDataProxy {
+    url: string;
+    config: any;
+    protected _url: string;
+    constructor(url: string, config?: {});
+    updateUrl(url?: string, params?: any): void;
+    load<T = string>(): Promise<T | void>;
+    save(data: any, mode: string): Promise<any>;
+}

package/codebase/types/ts-data/sources/drivers/CsvDriver.d.ts

@@ -0,0 +1,16 @@
+import { IDataDriver, ICsvDriverConfig } from "../types";
+import { IAnyObj } from "../../../ts-common/types";
+export interface ICsvDriver extends IDataDriver {
+    getFields(data: string, headers?: string[]): any;
+}
+export declare class CsvDriver implements ICsvDriver {
+    config: ICsvDriverConfig;
+    constructor(config?: ICsvDriverConfig);
+    getFields(row: string, headers?: string[]): {
+        [key: string]: any;
+    };
+    getRows(data: string): string[];
+    toJsonArray(data: string): any[];
+    serialize(data: IAnyObj[], withoutHeader?: boolean): string;
+    private _serialize;
+}

package/codebase/types/ts-data/sources/drivers/JsonDriver.d.ts

@@ -0,0 +1,10 @@
+import { IDataDriver } from "../types";
+import { IAnyObj } from "../../../ts-common/types";
+export declare class JsonDriver implements IDataDriver {
+    toJsonArray(data: any): any[];
+    serialize(data: IAnyObj[]): IAnyObj[];
+    getFields(row: any): {
+        [key: string]: any;
+    };
+    getRows(data: string): any[];
+}

package/codebase/types/ts-data/sources/drivers/XMLDriver.d.ts

@@ -0,0 +1,18 @@
+import { IDataDriver } from "../types";
+import { IAnyObj } from "../../../ts-common/types";
+export declare class XMLDriver implements IDataDriver {
+    toJsonArray(data: any): any[];
+    toJsonObject(data: string): {
+        [key: string]: any;
+    };
+    serialize(data: IAnyObj[]): string;
+    getFields(row: any): {
+        [key: string]: any;
+    };
+    getRows(data: Document | string): any[];
+    private _getRows;
+    private _fromString;
+    private _nodeToJS;
+    private _toType;
+    private _haveAttrs;
+}

package/codebase/types/ts-data/sources/drivers/drivers.d.ts

@@ -0,0 +1,12 @@
+import { JsonDriver } from "./JsonDriver";
+import { CsvDriver } from "./CsvDriver";
+import { XMLDriver } from "./XMLDriver";
+export declare const dataDrivers: {
+    json: typeof JsonDriver;
+    csv: typeof CsvDriver;
+};
+export declare const dataDriversPro: {
+    xml: typeof XMLDriver;
+    json: typeof JsonDriver;
+    csv: typeof CsvDriver;
+};