@rentman/rm-core 1.0.0 → 1.0.1

package/dist/definitions/classes/ApiFormatter.d.ts

@@ -0,0 +1,36 @@
+import * as moment from 'moment';
+export default class ApiFormatter {
+    MOMENT_INVALID: string;
+    SERVER_DATETIME_FORMAT: string;
+    SERVER_TIME_FORMAT: string;
+    SERVER_DATE_FORMAT: string;
+    constructor();
+    formatResponse(fields: any, columns: any): void;
+    expandResponse(current: any, expanded: any, columns: any): void;
+    formatRequest(initial: any, modified: any, columns: any): {};
+    hasChanges(initial: any, modified: any, columns: any): boolean;
+    getChanges(initial: any, modified: any, columns: any): any[];
+    copyFields(source: any, destination: any, columns: any): any;
+    shallowCopyFields(shallowSource: any, deepSource: any, destination: any, columns: any): any;
+    setDefaultValues(destination: any, columns: any): any;
+    compareFields(columnType: any, first: any, second: any): any;
+    compareFloats(a: any, b: any): boolean;
+    compareMomentObjects(first: any, second: any): any;
+    compareDurations(first: any, second: any): boolean;
+    formatResponseValue(columnType: any, value: any): any;
+    formatRequestValue(columnType: any, value: any): any;
+    formatResponseDate(value: any): moment.Moment;
+    formatResponseDuration(value: any): moment.Duration;
+    formatResponseColor(value: any): any;
+    formatRequestDateTime(value: any): any;
+    formatRequestDate(value: any): any;
+    formatRequestDuration(value: any): any;
+    formatRequestColor(value: any): any;
+    getDefaultValue(columnType: any): false | moment.Moment | 0 | moment.Duration | "0" | "" | "#000000";
+    isDefaultValue(columnType: any, value: any): any;
+    clone(columnType: any, value: any): any;
+    getCloneFunction(columnType: any): (date: any) => any;
+    cloneDuration(duration: any): moment.Duration;
+    cloneDate(date: any): any;
+    identity(input: any): any;
+}

package/dist/definitions/classes/BatchStatus.d.ts

@@ -0,0 +1,16 @@
+import ItemEntry from "../models/ItemEntry";
+import PromiseService from "./PromiseService";
+export default class BatchStatus {
+    private promiseService;
+    getItemId: (itemEntry: ItemEntry) => number;
+    getPromise: (itemEntry: ItemEntry) => Promise<any>;
+    entries: {};
+    constructor(promiseService: PromiseService, getItemId: (itemEntry: ItemEntry) => number, getPromise: (itemEntry: ItemEntry) => Promise<any>);
+    add(entryStatus: any): void;
+    hasEntries(statusArray: any): boolean;
+    hasRequests(): boolean;
+    forEachEntry(statusArray: any[], callback: any): void;
+    getPromises(): Promise<any>;
+    getRequestIds(): number[];
+    getArray(): any[];
+}

package/dist/definitions/classes/ChangesCompiler.d.ts

@@ -0,0 +1,34 @@
+import CollectionEntry from "../models/CollectionEntry";
+import ItemEntry from "../models/ItemEntry";
+import ItemEntryService from "./ItemEntryService";
+export default class ChangesCompiler {
+    private itemEntryService;
+    singleItems: ItemEntry[];
+    collections: CollectionEntry[];
+    private collectionOptions;
+    compilation: {
+        create: {};
+        delete: {};
+        update: {};
+        move: {};
+    };
+    private moveArray;
+    private deleteMap;
+    constructor(itemEntryService: ItemEntryService, singleItems: ItemEntry[], collections: CollectionEntry[], collectionOptions: any);
+    getParent(itemEntry: ItemEntry): {
+        itemType: string;
+        itemId: string;
+    } | {
+        itemType: string;
+        itemId: number;
+    };
+    addMoveEntry(itemEntry: any): void;
+    addDeleteEntry(itemEntry: any, parentId: any, parentType: any): void;
+    addUpdateEntry(itemEntry: any): void;
+    addCreateEntry(itemEntry: any): void;
+    postProcess(): void;
+    private processSingleItems;
+    private isEditableCollection;
+    private hasEditableItems;
+    private processCollections;
+}

package/dist/definitions/classes/ChangesProcessor.d.ts

@@ -0,0 +1,46 @@
+import ChangesCompilerFactory from "../factories/ChangesCompilerFactory";
+import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
+import CreateRequestFactory from "../factories/CreateRequestFactory";
+import RequestColumnExpansionFactory from "../factories/RequestColumnExpansionFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ApiFormatter from "./ApiFormatter";
+import CollectionEntryService from "./CollectionEntryService";
+import CollectionHandler from "./CollectionHandler";
+import ColumnHandler from "./ColumnHandler";
+import ItemEntryService from "./ItemEntryService";
+import ItemHandler from "./ItemHandler";
+import PromiseService from "./PromiseService";
+export default class ChangesProcessor {
+    private apiRequestService;
+    private itemHandler;
+    private errorHandler;
+    private collectionHandler;
+    private columnHandler;
+    private changesCompilerFactory;
+    private createRequestFactory;
+    private columnExpansionFactory;
+    private requestColumnExpansionFactory;
+    private collectionEntryService;
+    private itemEntryService;
+    private apiFormatter;
+    private promiseService;
+    constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, columnHandler: ColumnHandler, changesCompilerFactory: ChangesCompilerFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, promiseService: PromiseService);
+    getItemTypeUpdatePriority(itemType: any): 0 | 1 | 2;
+    buildMoveRequest(compilationEntries: any): {};
+    getMapValue(itemType: any, itemId: any, map: any): any;
+    execute(singleItems: any, collections: any, breakupByParent?: boolean, parameters?: any, collectionOptions?: any, onAfterCreateCallback?: any): Promise<any>;
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private prioritizeUpdateRequests;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+    private executeMoveRequests;
+    private processMoveResponse;
+    private addCollectionMapEntry;
+    private forEachCollection;
+    private onItemsCreated;
+    private executeRequests;
+}

package/dist/definitions/classes/CollectionCache.d.ts

@@ -0,0 +1,39 @@
+import QueryMatcherFactory from "../factories/QueryMatcherFactory";
+import CollectionEntry from "../models/CollectionEntry";
+export default class CollectionCache {
+    private queryMatcherFactory;
+    entries: {};
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    contains(collectionEntry: any): boolean;
+    some(callback: any): boolean;
+    forEach(callback: any): void;
+    toArray(): any[];
+    add(collectionEntry: CollectionEntry): CollectionEntry;
+    clear(collectionEntry?: CollectionEntry): boolean;
+    getByItemType(itemType: any): any;
+    getByParent(parentType: any, parentId: any, itemType: any): any;
+    getResourceByParent(parentType: any, parentId: any, itemType: any): any;
+    getCollectionsByParent(parentType: any, parentId: any): any[];
+    /**
+     * Only resources
+     * @param {String} itemType
+     * @param {String|Integer} itemId
+     * @returns {Object} Array of collections.
+     */
+    getByContainingItem(itemType: any, itemId: any): any[];
+    /**
+     * Returns an array of collections the item 'belongs' in.
+     * @param {String} parentType
+     * @param {String} parentId
+     * @param {String} itemType
+     * @returns {Object}
+     */
+    getByFittingItem(parentType: any, parentId: any, itemType: any, fields: any): {
+        fitting: any[];
+        notfitting: any[];
+        maybe: any[];
+    };
+    getByQuery(itemType: any, query: any): any;
+    getByKey(itemType: any, entryKey: any): any[];
+    getResourceByKey(itemType: any, resourceKey: any): any[];
+}

package/dist/definitions/classes/CollectionEntryService.d.ts

@@ -0,0 +1,15 @@
+import QueryParserFactory from "../factories/QueryParserFactory";
+import ItemEntry from "../models/ItemEntry";
+import QueryService from './QueryService';
+export default class CollectionEntryService {
+    private queryParserFactory;
+    private queryService;
+    constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
+    processOptions(options: any): any;
+    createQuery(options: any): {
+        object: any;
+        string: any;
+    };
+    getIdArray(itemEntries: ItemEntry[], accumulator: any): any;
+    filterArray(itemEntries: ItemEntry[], callback: any): any[];
+}

package/dist/definitions/classes/CollectionHandler.d.ts

@@ -0,0 +1,79 @@
+import CollectionCacheFactory from "../factories/CollectionCacheFactory";
+import CollectionEntryFactory from "../factories/CollectionEntryFactory";
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import QueryParserFactory from "../factories/QueryParserFactory";
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import CollectionResource from "../models/CollectionResource";
+import ItemEntry from "../models/ItemEntry";
+import ItemResource from "../models/ItemResource";
+import CollectionCache from "./CollectionCache";
+import CollectionEntryService from "./CollectionEntryService";
+import ColumnHandler from "./ColumnHandler";
+import ColumnUtil from "./ColumnUtil";
+import ItemCache from "./ItemCache";
+import ItemEntryService from "./ItemEntryService";
+import ItemHandler from "./ItemHandler";
+import ItemRequestService from "./ItemRequestService";
+import KeyService from "./KeyService";
+import PromiseService from "./PromiseService";
+import QueryService from "./QueryService";
+export default class CollectionHandler {
+    private errorHandler;
+    private itemRequestService;
+    private itemHandler;
+    private columnHandler;
+    private collectionEntryFactory;
+    private collectionCacheFactory;
+    private queryParserFactory;
+    private collectionEntryService;
+    private columnSetFactory;
+    private itemEntryService;
+    private keyService;
+    private promiseService;
+    private queryService;
+    private columnUtil;
+    entries: CollectionCache;
+    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, itemHandler: ItemHandler, columnHandler: ColumnHandler, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseService, queryService: QueryService, columnUtil: ColumnUtil);
+    getPromises(statusResource: any): any[];
+    getRequestIds(statusResource: any): any[];
+    removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
+    removeFromCollections(collectionMap: any, updateInitial?: any, resultResource?: CollectionResource | null): any;
+    /**
+     * @deprecated
+     */
+    addItemsToCollections(itemEntries: ItemEntry[]): any;
+    addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: ItemResource | null): any;
+    batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): Promise<any>;
+    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): {};
+    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): Promise<any>;
+    clone(collectionEntry: CollectionEntry, options: any, conversionMap?: {}): CollectionEntry;
+    create(itemType: string, options: any, columns: any, items: ItemEntry[]): CollectionEntry;
+    createCollectionMap(itemEntries: ItemEntry[]): {};
+    createStatusResource(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): {};
+    expandCollectionMap(itemEntry: ItemEntry, accumulator: any, collectionCache?: CollectionCache): void;
+    fetch(itemType: string, options: any, itemCache: ItemCache, deferredCollectionCache: CollectionCache): any;
+    getDeferredEntryStatus(collectionEntry: CollectionEntry, options: any): {
+        entry: CollectionEntry;
+        status: string;
+    };
+    getEntryStatus(itemType: string, options: any, deferredEntries: CollectionCache): {
+        entry: any;
+        status: string;
+    };
+    getNewEntryStatus(itemType: string, query: any, options: any, deferredEntries: CollectionCache): {
+        entry: any;
+        status: string;
+    };
+    handleBatchResponse(statusResource: any, itemEntryResource: any): {};
+    /**
+     * @deprecated
+     */
+    removeItemsFromAndAddItemsToCollections(itemEntries: ItemEntry[]): void;
+    /**
+     * @deprecated
+     */
+    removeItemsFromCollections(itemEntries: ItemEntry[]): any;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): Promise<any>;
+    resolveRemote(collectionEntry: any, itemCache: any): Promise<any>;
+}

package/dist/definitions/classes/CollectionResourceService.d.ts

@@ -0,0 +1,5 @@
+import ItemResource from "../models/ItemResource";
+export default class CollectionResourceService {
+    processOptions(options: any): any;
+    getIdArray(itemResources: ItemResource[]): any[];
+}

package/dist/definitions/classes/ColumnCache.d.ts

@@ -0,0 +1,18 @@
+import ColumnUtil from './ColumnUtil';
+export default class ColumnCache {
+    private columnUtil;
+    cache: {};
+    allColumns: {};
+    constructor(columnUtil: ColumnUtil);
+    setColumn(itemType: any, responseColumn: any): any;
+    setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
+    retrieve(itemType: any, requestColumns: any): {
+        missing: any[] | true;
+        cached: object;
+    };
+    containsAll(itemType: any): boolean;
+    getColumns(itemType: any): {};
+    private retrieveColumns;
+    private retrieveColumn;
+    private getColumn;
+}

package/dist/definitions/classes/ColumnExpansion.d.ts

@@ -0,0 +1,16 @@
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import ColumnHandler from "./ColumnHandler";
+import ColumnUtil from "./ColumnUtil";
+export default class ColumnExpansion {
+    private columnHandler;
+    private columnSetFactory;
+    private columnUtil;
+    itemType: string;
+    requestColumns: any | boolean;
+    responseColumns: any;
+    expansionMap: any;
+    requestColumnsTrue: boolean;
+    constructor(columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, itemType: string, requestColumns: any | boolean, responseColumns: any);
+    run(columnInfo: any, returnExpansionResult: boolean): any;
+    private expandColumnInfo;
+}

package/dist/definitions/classes/ColumnHandler.d.ts

@@ -0,0 +1,19 @@
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ColumnCache from './ColumnCache';
+import ColumnUtil from './ColumnUtil';
+import PromiseService from "./PromiseService";
+export default class ColumnHandler {
+    private apiRequestService;
+    private errorHandler;
+    private promiseService;
+    private cache;
+    private columnUtil;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseService, cache: ColumnCache, columnUtil: ColumnUtil);
+    setColumn(itemType: any, responseColumn: any): void;
+    setColumns(itemType: any, requestColumns: any, responseColumns: any): void;
+    fetchItemTypeTranslations(itemTypes: any): Promise<any>;
+    request(itemType: any, columns: any, params?: {}): Promise<any>;
+    fetch(itemType: any, requestColumns: any, params?: {}): Promise<any>;
+    fetchAll(itemType: any): Promise<any>;
+}

package/dist/definitions/classes/ColumnSet.d.ts

@@ -0,0 +1,54 @@
+import ColumnHandler from './ColumnHandler';
+import ColumnUtil from './ColumnUtil';
+export default class ColumnSet {
+    private columnHandler;
+    private columnUtil;
+    itemType: any;
+    requestColumns: any;
+    responseColumns: any;
+    enableCaching: boolean;
+    includeIdColumn: boolean;
+    id: number;
+    true: boolean;
+    link: any;
+    main: any[];
+    derived: any[];
+    root: any[];
+    leaf: any[];
+    formatted: {
+        main: any[];
+        derived: any[];
+    };
+    filtered: any[];
+    custom: any[];
+    searchable: any[];
+    item: any[];
+    notItem: any[];
+    request: any[];
+    response: {};
+    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, itemType: any, requestColumns: any, responseColumns: any, enableCaching?: boolean, includeIdColumn?: boolean);
+    processResponseColumns(): void;
+    processRequestColumns(): void;
+    getRequestColumnInfo(requestColumn: any, columnType: any, parent: any): {
+        id: any;
+        path: any;
+        apiColumn: any;
+        level: any;
+        isLeaf: boolean;
+        itemType: string;
+        children: any[];
+        parent: any;
+        tailPath: any;
+    };
+    getColumnInfo(responseColumn: any, children: any, parent: any): {
+        id: any;
+        path: any;
+        apiColumn: any;
+        level: any;
+        isLeaf: boolean;
+        itemType: string;
+        children: any[];
+        parent: any;
+        tailPath: any;
+    };
+}

package/dist/definitions/classes/ColumnUtil.d.ts

@@ -0,0 +1,80 @@
+export default class ColumnUtil {
+    constructor();
+    getColumnPath(columns: any, renderAs: any): string;
+    getDateFormatOptions(columnType: any): {
+        'J-M-Y': string;
+        'J-M': string;
+        'j+F+Y': string;
+        'D+j+F+Y': string;
+        'F': string;
+        'f': string;
+        'D': string;
+        'd': string;
+    };
+    isFloatColumn(column: any): boolean;
+    isIntColumn(column: any): boolean;
+    isNumberColumn(column: any): boolean;
+    isCustomColumn(column: any): boolean;
+    isItemColumn(column: any, includeId?: boolean): boolean;
+    isDateColumn(column: any): boolean;
+    isRenderedColumn(column: any): boolean;
+    isFilteredColumn(column: any): boolean;
+    isFormattedColumn(column: any): boolean;
+    isSelectableColumn(column: any): boolean;
+    hasLocationProperty(column: any, location: any): boolean;
+    isEditableColumn(column: any): boolean;
+    isSearchableColumn(column: any): boolean;
+    getDefaultWeight(column: any): 1 | 0.5 | 1.5 | 2;
+    getComparators(column: any): string[];
+    isColumnSubset(first: any, second: any, secondTrue: any): any;
+    containsColumn(requestColumn: any, destination: any): boolean;
+    responseColumnsAvailable(itemType: any, requestColumns: any, responseColumnMap: any): boolean;
+    /**
+     * Difference: columns that are in second, but not in first
+     * @param {Array} first
+     * @param {Array} second
+     * @returns {Object} An object containing 'merged' and 'difference' properties
+     */
+    mergeRequestColumns(first: any, second: any): {
+        merged: boolean;
+        difference: boolean;
+    } | {
+        merged: any;
+        difference: any[];
+    };
+    mergeRequestColumn(requestColumn: any, destination: any): any;
+    parseRequestColumn(requestColumn: any): {
+        id: any;
+        children: any;
+    };
+    /**
+     * Merges two sets of response columns.
+     * @param {object} first
+     * @param {object} second
+     * @returns {object} An object containing a 'merged' and a 'difference' property.
+     */
+    mergeResponseColumns(first: any, second: any): {
+        merged: {};
+        difference: {};
+    };
+    /**
+     * @param {array} first
+     * @param {array} second
+     * @returns {object} difference: the columns that are in second, but not in first.
+     */
+    mergeResponseColumnMap(first: any, second: any): {
+        merged: {};
+        difference: {};
+    };
+    isLocalColumnId(columnId: any): boolean;
+    processConfigColumns(columns: any): any[];
+    processLocalConfigColumns(configColumns: any, localColumns: any, remoteColumnCallback: any, localColumnCallback: any): void;
+    consolidateColumns(configColumns: any, localColumns: any, addRequestColumns: any): {
+        request: any;
+        local: any[];
+    };
+    parseConfigColumn(column: any): any;
+    processConfigColumn(columnArray: any, destination: any): void;
+    findColumnObject(columnId: any, array: any): number;
+    findColumn(columnId: any, array: any): number;
+}

package/dist/definitions/classes/CreateRequest.d.ts

@@ -0,0 +1,28 @@
+import RequestColumnExpansionFactory from "../factories/RequestColumnExpansionFactory";
+import CollectionHandler from "./CollectionHandler";
+import ItemEntryService from "./ItemEntryService";
+import KeyService from "./KeyService";
+export default class CreateRequest {
+    private collectionHandler;
+    private requestColumnExpansionFactory;
+    private itemEntryService;
+    private keyService;
+    private compilation;
+    private parameterMap;
+    private breakupByParent;
+    requests: any[];
+    constructor(collectionHandler: CollectionHandler, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, keyService: KeyService, compilation: any, parameterMap: any, breakupByParent?: boolean);
+    finalizeRequest(requestResource: any): any;
+    setRequestParent(parentType: any, requestResource: any): boolean;
+    run(): any[];
+    initializeRequest(): {
+        request: {
+            requestType: string;
+            items: {};
+        };
+        columns: import("./RequestColumnExpansion").default;
+        items: {};
+        collections: {};
+    };
+    private extendRequest;
+}

package/dist/definitions/classes/ItemAdministrator.d.ts

@@ -0,0 +1,114 @@
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import ModuleChangesCompilerFactory from "../factories/ModuleChangesCompilerFactory";
+import ResourceCacheFactory from "../factories/ResourceCacheFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import AuthInterface from '../interfaces/AuthInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ResourceCacheInterface from '../interfaces/ResourceCacheInterface';
+import CollectionEntryService from "./CollectionEntryService";
+import CollectionHandler from "./CollectionHandler";
+import CollectionResourceService from './CollectionResourceService';
+import ItemEntryService from './ItemEntryService';
+import ItemHandler from './ItemHandler';
+import ItemRequestService from "./ItemRequestService";
+import KeyService from "./KeyService";
+import QueryService from "./QueryService";
+import ResourceCache from "./ResourceCache";
+export default class ItemAdministrator {
+    private apiRequestService;
+    private resourceCacheInterface;
+    private authInterface;
+    private errorHandler;
+    private itemHandler;
+    private collectionHandler;
+    private columnSetFactory;
+    private itemRequestService;
+    private resourceCacheFactory;
+    private moduleChangesCompilerFactory;
+    private collectionEntryService;
+    private collectionResourceService;
+    private itemEntryService;
+    private keyService;
+    private queryService;
+    constructor(apiRequestService: ApiRequestServiceInterface, resourceCacheInterface: ResourceCacheInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, itemRequestService: ItemRequestService, resourceCacheFactory: ResourceCacheFactory, moduleChangesCompilerFactory: ModuleChangesCompilerFactory, collectionEntryService: CollectionEntryService, collectionResourceService: CollectionResourceService, itemEntryService: ItemEntryService, keyService: KeyService, queryService: QueryService);
+    getItemDefinition(itemType: string, itemId: any, options: any): {
+        itemType: string;
+        options: any;
+        itemId: any;
+    };
+    createCollectionMap(itemEntries: any[], addToTab: boolean): {};
+    getItemById(itemType: string, itemId: number, options: any): any;
+    getItemsById(itemType: string, itemIds: number[], options: any): Promise<any>;
+    getItemsByQuery(itemType: string, query: any, options: any): Promise<any>;
+    getDuplicateById(itemType: string, duplicateId: number, options: any): any;
+    getNewResource(itemType: string, options: any, returnLinks: boolean, isRoot: boolean): any;
+    getCollectionDef(itemType: string, options: any): {
+        itemType: string;
+        options: {
+            entry: any;
+            resource: any;
+        };
+    };
+    getLinkCollectionsDef(linkType: string, linkIdArray: number[], itemType: string, linkField: string, options: any): {
+        itemType: string;
+        linkType: string;
+        linkIdArray: number[];
+        linkField: string;
+        options: {
+            entry: any;
+            resource: any;
+        };
+    };
+    /** @deprecated */
+    getCollection(itemType: string, query: any, options: any): any;
+    _getCollection(itemType: string, options: any): any;
+    getCollectionFromDef(definition: any): any;
+    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): any;
+    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): Promise<any>;
+    getLinkCollectionsFromDef(definition: any): Promise<any>;
+    getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<any>;
+    getItemByDef(definition: any, isRoot: boolean): any;
+    cloneItem(newItemId: number, itemResource: any, options: any): import("../models/ItemResource").default;
+    cloneCollection(collectionResource: any, options: any, conversionMap: any): import("../models/CollectionResource").default;
+    /**
+     * @deprecated
+     */
+    saveCurrentTab(closeTab: any, parameters: any, breakupByParent: any, onAfterCreateCallback: any, keepTabHeading: any): any;
+    saveCurrentResourceCache(closeTab: boolean, parameters: any, breakupByParent: boolean, onAfterCreateCallback: any, keepTabHeading?: boolean): any;
+    getCurrentCollections(): import("./CollectionCache").default;
+    getCurrentItems(): import("./ItemCache").default;
+    getCurrentChanges(): void;
+    addSingleItem(itemEntry: any, options: any, isRoot?: boolean): import("../models/ItemResource").default;
+    addSingleItems(itemEntries: any[], options: any): any[];
+    addCollection(collectionEntry: any, resourceOptions: any, processOptions?: any): import("../models/CollectionResource").default;
+    addCollections(collectionEntries: any[], resourceOptions: any): {};
+    processLinkedItems(linkedEntries: any[], options: any, addToCollections: boolean): {};
+    /**
+     * @deprecated
+     */
+    getTabEntry(): ResourceCache;
+    getResourceCache(): ResourceCache;
+    /**
+     * @deprecated
+     */
+    resetTabEntry(): void;
+    resetResourceCache(): void;
+    addToCollections(itemEntries: any[], resultCollectionResource: any): any;
+    removeFromCollections(itemEntries: any[], resultCollectionResource: any): any;
+    updateItemIdMap(collectionMap: any, conversionMap: any): void;
+    createCollectionResource(collectionEntry: any, resourceOptions: any, processOptions?: any): import("../models/CollectionResource").default;
+    createItemResource(itemEntry: any, options: any, isRoot: boolean): import("../models/ItemResource").default;
+    createItemResources(itemEntries: any[], options: any): any[];
+    /**
+     * @deprecated
+     */
+    onBeforeSave(key: string, callback: any): () => void;
+    /**
+     * @deprecated
+     */
+    onSaveSuccess(key: string, callback: any): () => void;
+    /**
+     * @deprecated
+     */
+    onSaveWithoutClosing(key: string, callback: any): () => void;
+}

package/dist/definitions/classes/ItemCache.d.ts

@@ -0,0 +1,22 @@
+import QueryMatcherFactory from "../factories/QueryMatcherFactory";
+import ItemEntry from "../models/ItemEntry";
+import ItemEntryService from "./ItemEntryService";
+export default class ItemCache {
+    private queryMatcherFactory;
+    private itemEntryService;
+    entries: {};
+    constructor(queryMatcherFactory: QueryMatcherFactory, itemEntryService: ItemEntryService);
+    some(callback: any): boolean;
+    getByItemType(itemType: any): any[];
+    getByQuery(itemType: any, query: any): any[];
+    getLocalByQuery(itemType: any, query: any): any[];
+    forEach(callback: any): void;
+    toArray(): any[];
+    add(itemEntry: ItemEntry): ItemEntry;
+    get(itemType: any, itemId: any): any;
+    getByParent(parentType: any, parentId: any, itemType: any): any[];
+    contains(itemType: any, itemId: any): boolean;
+    updateItemId(itemEntry: ItemEntry, oldItemId: any): ItemEntry;
+    clear(itemEntry: ItemEntry): boolean;
+    matchQuery(itemEntry: ItemEntry, query: any): boolean;
+}