@rentman/rm-core 1.0.34 → 1.1.0

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

@@ -1,114 +1,99 @@
-import { ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilerFactory } from "../factories";
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface } from '../interfaces';
-import { CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemResourceItemTypeMap, TemplateResponseItemEntryMap } from '../types/ItemTypesCollection';
-import { CollectionCache } from './CollectionCache';
-import { CollectionEntryService } from "./CollectionEntryService";
-import { CollectionHandler } from "./CollectionHandler";
-import { CollectionResourceService } from './CollectionResourceService';
-import { ItemCache } from './ItemCache';
-import { ItemEntryService } from './ItemEntryService';
-import { ItemHandler } from './ItemHandler';
-import { ItemRequestService } from "./ItemRequestService";
-import { KeyService } from "./KeyService";
-import { LocalCache } from "./LocalCache";
-import { QueryService } from "./QueryService";
-export declare class ItemAdministrator {
-    private apiRequestService;
-    private localCacheManager;
-    private authInterface;
-    private errorHandler;
-    private itemHandler;
-    private collectionHandler;
-    private columnSetFactory;
-    private itemRequestService;
-    private localCacheFactory;
-    private moduleChangesCompilerFactory;
-    private collectionEntryService;
-    private collectionResourceService;
-    private itemEntryService;
-    private keyService;
-    private queryService;
-    constructor(apiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, itemRequestService: ItemRequestService, localCacheFactory: LocalCacheFactory, 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): {};
-    /**
-     *
-     * @param {string} itemType
-     * @param {number} itemId
-     * @param options
-     * @returns {Promise<ItemResource>}
-     *
-     * I expect not a template request from itemhandler.fetchItem because addSingleItem does not handle the
-     * TemplateResponseItemEntryMap
-     */
-    getItemById(itemType: string, itemId: number, options: any): Promise<ItemResource>;
-    getItemsById(itemType: string, itemIds: number[], options: any): Promise<ItemResource[]>;
-    getItemsByQuery(itemType: string, query: any, options: any): Promise<ItemResource[]>;
-    getDuplicateById(itemType: string, duplicateId: number, options: any): Promise<any>;
-    /**
-     * The return value is depended on the return links boolean. true returns the TemplateResponseItemEntryMap.
-     * The type has to be asserted at use since you only know the type of the return value when the function is called
-     *
-     * @param {string} itemType
-     * @param options
-     * @param {boolean} returnLinks
-     * @param {boolean} isRoot
-     * @returns {Promise<ItemResource> | Promise<TemplateResponseItemEntryMap>}
-     */
-    getNewResource(itemType: string, options: any, returnLinks: boolean, isRoot: boolean): Promise<ItemResource> | Promise<TemplateResponseItemEntryMap>;
-    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;
-        };
-    };
-    getCollection(itemType: string, options: any): Promise<CollectionResource>;
-    getCollectionFromDef(definition: any): Promise<CollectionResource>;
-    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): Promise<CollectionResource>;
-    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): Promise<CollectionResourceParentIdMap>;
-    getLinkCollectionsFromDef(definition: any): Promise<CollectionResourceParentIdMap>;
-    getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<CollectionEntryParentIdMap>;
-    getItemByDef(definition: any, isRoot: boolean): Promise<any>;
-    cloneItem(newItemId: number, itemResource: any, options: any): ItemResource;
-    cloneCollection(collectionResource: any, options: any, conversionMap: any): CollectionResource;
-    saveCurrentLocalCache(closeTab: boolean, parameters: any, breakupByParent: boolean, onAfterCreateCallback: any, keepTabHeading?: boolean): any;
-    getCurrentCollections(): CollectionCache;
-    getCurrentItems(): ItemCache;
-    getCurrentChanges(): {
-        itemType: string;
-        itemId: number;
-        items: any;
-    };
-    addSingleItem(itemEntry: ItemEntry, options: any, isRoot?: boolean): ItemResource;
-    addSingleItems(itemEntries: ItemEntry[], options: any): ItemResource[];
-    addCollection(collectionEntry: any, resourceOptions: any, processOptions?: any): CollectionResource;
-    addCollections(collectionEntries: CollectionEntryParentIdMap, resourceOptions: any): CollectionResourceParentIdMap;
-    processLinkedItems(linkedEntries: any[], options: any, addToCollections: boolean): ItemResourceItemTypeMap;
-    getLocalCache(): LocalCache;
-    resetLocalCache(): void;
-    addToCollections(itemEntries: any[], resultCollectionResource: any): ItemResource[];
-    removeFromCollections(itemEntries: any[], resultCollectionResource: any): any;
-    updateItemIdMap(collectionMap: any, conversionMap: any): void;
-    createCollectionResource(collectionEntry: any, resourceOptions: any, processOptions?: any): CollectionResource;
-    createItemResource(itemEntry: any, options: any, isRoot: boolean): ItemResource;
-    createItemResources(itemEntries: any[], options: any): ItemResource[];
-    onBeforeSave(key: string, callback: any): () => void;
-    onSaveSuccess(key: string, callback: any): () => void;
-    onSaveWithoutClosing(key: string, callback: any): () => void;
-}
+import { CollectionCache, CollectionEntryService, CollectionHandler, CollectionMatcher, CollectionResourceService, ItemCache, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
+import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemId, ItemResourceItemTypeMap, ItemType, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
+export declare class ItemAdministrator {
+    private apiRequestService;
+    private authInterface;
+    private collectionEntryService;
+    private collectionHandler;
+    private collectionMatcherFactory;
+    private collectionResourceService;
+    private columnSetFactory;
+    private errorHandler;
+    private itemEntryService;
+    private itemHandler;
+    private itemRequestService;
+    private keyService;
+    private localCacheFactory;
+    private localCacheManager;
+    private moduleChangesCompilationFactory;
+    private promiseInterface;
+    private queryService;
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceService: CollectionResourceService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseInterface, queryService: QueryService);
+    getItemDefinition(itemType: ItemType, itemId: any, options: any): {
+        itemType: string;
+        options: any;
+        itemId: any;
+    };
+    getCollectionMatcher(itemEntries: ItemEntry[], addToTab: boolean): CollectionMatcher;
+    fetchTitle(itemType: any, itemId: any, deferRequest: any): Promise<any>;
+    getItemById(itemType: ItemType, itemId: ItemId, options: any): Promise<ItemResource>;
+    getItemsById(itemType: string, itemIds: number[], options: any): Promise<ItemResource[]>;
+    getItemsByQuery(itemType: string, query: any, options: any): Promise<ItemResource[]>;
+    getDuplicateById(itemType: string, duplicateId: number, options: any): Promise<any>;
+    /**
+     * The return value is depended on the return links boolean. true returns the TemplateResponseItemEntryMap.
+     * The type has to be asserted at use since you only know the type of the return value when the function is called
+     *
+     * @param {string} itemType
+     * @param options
+     * @param {boolean} returnLinks
+     * @param {boolean} isRoot
+     * @returns {Promise<ItemResource> | Promise<TemplateResponseItemEntryMap>}
+     */
+    getNewResource(itemType: string, options?: any, returnLinks?: boolean, isRoot?: boolean): Promise<ItemResource> | Promise<TemplateResponseItemEntryMap>;
+    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;
+        };
+    };
+    getCollection(itemType: string, options: any): Promise<CollectionResource>;
+    getCollectionFromDef(definition: any): Promise<CollectionResource>;
+    /**
+     * @deprecated, use `parent` in options
+     */
+    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): Promise<CollectionResource>;
+    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): Promise<CollectionResourceParentIdMap>;
+    getLinkCollectionsFromDef(definition: any): Promise<CollectionResourceParentIdMap>;
+    getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<CollectionEntryParentIdMap>;
+    getItemByDef(definition: any, isRoot: boolean): Promise<any>;
+    cloneItem(itemResource: ItemResource, options: any): ItemResource;
+    cloneCollection(collectionResource: CollectionResource, options: any, conversionMap: any): CollectionResource;
+    saveCurrentLocalCache(closeTab: boolean, parameters: any, breakupByParent: boolean | undefined, onAfterCreateCallback: any): any;
+    getCurrentCollections(): CollectionCache;
+    getCurrentItems(): ItemCache;
+    getCurrentChanges(): {
+        itemType: string;
+        itemId: number;
+        items: any;
+    };
+    addSingleItem(itemEntry: ItemEntry, options: any, isRoot?: boolean, localCache?: LocalCache): ItemResource;
+    addSingleItems(itemEntries: ItemEntry[], options: any): ItemResource[];
+    addCollection(collectionEntry: CollectionEntry, options: any): CollectionResource;
+    processLinkedItems(linkedEntries: TemplateResponseLinkedItemEntryMap[], options: any, addToCollections: boolean): ItemResourceItemTypeMap;
+    getLocalCache(): LocalCache;
+    resetLocalCache(): void;
+    addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
+    removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
+    saveLocal(itemResource: ItemResource): Promise<any>;
+    updateItemIdMap(collectionMap: any, conversionMap: any): void;
+    createCollectionResource(collectionEntry: any, resourceOptions: any, processOptions?: boolean): CollectionResource;
+    createItemResource(itemEntry: any, options: any, isRoot: boolean): ItemResource;
+    onBeforeSave(key: string, callback: any): () => void;
+    onSaveSuccess(key: string, callback: any): () => void;
+    onSaveWithoutClosing(key: string, callback: any): () => void;
+}

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

@@ -1,22 +1,25 @@
-import { QueryMatcherFactory } from "../factories";
-import { ItemEntry } from "../models";
-import { ItemEntryService } from "./ItemEntryService";
-export declare class ItemCache {
-    private queryMatcherFactory;
-    private itemEntryService;
-    entries: {};
-    constructor(queryMatcherFactory: QueryMatcherFactory, itemEntryService: ItemEntryService);
-    some(callback: (itemEntry) => boolean): 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;
-}
+import { QueryMatcherFactory } from '../factories';
+import { ItemEntry } from '../models';
+import { ItemId, ItemType } from '../types';
+export declare class ItemCache {
+    private queryMatcherFactory;
+    entries: {
+        [itemType: string]: {
+            [itemId: number]: ItemEntry;
+        };
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    some(callback: (itemEntry: ItemEntry) => boolean): boolean;
+    getByItemType(itemType: ItemType): ItemEntry[];
+    getByQuery(itemType: ItemType, query: any): ItemEntry[];
+    getLocalByQuery(itemType: ItemType, query: any): ItemEntry[];
+    forEach(callback: (itemEntry: ItemEntry) => void): void;
+    toArray(): ItemEntry[];
+    add(itemEntry: ItemEntry): ItemEntry;
+    get(itemType: ItemType, itemId: ItemId | string): any;
+    contains(itemType: ItemType, itemId: ItemId | string): boolean;
+    getByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): ItemEntry[];
+    updateItemId(itemEntry: ItemEntry, oldItemId: any): ItemEntry;
+    clear(itemEntry: ItemEntry): boolean;
+    matchQuery(itemEntry: ItemEntry, query: any): boolean;
+}

package/dist/dist/classes/ItemEntryService.d.ts

@@ -1,51 +1,18 @@
-import { PromiseInterface } from '../interfaces';
-import { ItemEntry } from '../models/';
-import { ApiFormatter } from './ApiFormatter';
-import { KeyService } from './KeyService';
-export declare class ItemEntryService {
-    private apiFormatter;
-    private keyService;
-    private promiseService;
-    undefinedItemError: string;
-    ALL_PERMISSIONS: number;
-    constructor(apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseInterface);
-    resetDerived(itemEntry: any, columnIds: any): void;
-    defer(itemEntry: ItemEntry, deferRequest: any): ItemEntry;
-    resolve(itemEntry: any): ItemEntry;
-    reject(itemEntry: any, error?: string): ItemEntry;
-    clearResources(itemEntry: any): void;
-    deactivateResources(itemEntry: any): void;
-    getFields(itemEntry: any): any;
-    expand(entry: any, main: any, derived: any, expandResource: any): any;
-    processOptions(options: any): any;
-    getConversionValue(itemType: any, itemId: any, map: any): any;
-    updateFields(entry: any, source: any, overwrite?: boolean): any;
-    updateItemValue(entry: any, fields: any, apiColumn: any, conversionMap: any): void;
-    updateItemFields(entry: any, conversionMap: any): void;
-    process(entry: any): any;
-    formatRequest(entry: any): {};
-    setDisplayName(entry: any): void;
-    getDisplayName(entry: any): any;
-    getFullName(firstName: any, infix: any, lastName: any): any;
-    getTitleField(itemType: any): "serienummer" | "nummer" | "friendlyname" | "naamintern" | "omschrijving" | "code" | "naam" | "displayname";
-    /**
-     *
-     * @param {Object} entry
-     * @param {Boolean} returnAll Returns all initial values if true
-     * @returns {Object}
-     */
-    getChanges(entry: any, returnAll: any): any[];
-    isLocal(entry: any): boolean;
-    isLockable(entry: any): boolean;
-    hasChanges(entry: any): boolean;
-    resetModified(entry: any): void;
-    setInitial(entry: any, values: any, enableCallbacks?: any): any;
-    /**
-     * Does a shallow copy of values!
-     */
-    setModified(entry: any, values?: any): any;
-    setDerived(entry: any, values: any): any;
-    processLocal(entry: any, initial: any, modified: any, derived: any, conversionMap: any): any;
-    setParent(entry: any, parentType: any, parentId: any): any;
-    callOnChange(entry: any, previous: any): void;
-}
+import { KeyService } from '../classes';
+import { ItemEntry } from '../models';
+import { ApiResponse, ItemId, ItemIdConversionMap, ItemType } from '../types';
+export declare class ItemEntryService {
+    private keyService;
+    undefinedItemError: string;
+    ALL_PERMISSIONS: number;
+    constructor(keyService: KeyService);
+    processOptions(options: any): any;
+    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
+    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
+    expandConversionMap(itemEntry: ItemEntry, conversionMap: ItemIdConversionMap, newItemId?: ItemId): any;
+    batchExpandConversionMap(itemEntries: ItemEntry[], conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    getConversionValue(itemType: any, itemId: any, map: any): any;
+    batchClone(itemEntries: ItemEntry[], conversionMap?: ItemIdConversionMap): ItemEntry[];
+    getFullName(firstName: any, infix: any, lastName: any): any;
+    getTitleField(itemType: any): "serienummer" | "nummer" | "friendlyname" | "naamintern" | "omschrijving" | "code" | "naam" | "displayname";
+}

package/dist/dist/classes/ItemHandler.d.ts

@@ -1,82 +1,57 @@
-import { ENTRY_STATUS } from "../constants";
-import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory } from "../factories";
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { ItemEntry } from "../models";
-import { ApiTemplateItemTypeMap, EntryStatus, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types/ItemTypesCollection';
-import { ApiFormatter } from "./ApiFormatter";
-import { ApiResponseProcessor } from './ApiResponseProcessor';
-import { BatchStatus } from './BatchStatus';
-import { ColumnHandler } from './ColumnHandler';
-import { ColumnUtil } from './ColumnUtil';
-import { ItemCache } from "./ItemCache";
-import { ItemEntryService } from "./ItemEntryService";
-import { KeyService } from "./KeyService";
-export declare class ItemHandler {
-    private apiRequestService;
-    private authInterface;
-    private errorHandler;
-    private itemEntryFactory;
-    private columnHandler;
-    private itemCacheFactory;
-    private batchStatusFactory;
-    private columnExpansionFactory;
-    private columnSetFactory;
-    private itemEntryService;
-    private apiFormatter;
-    private keyService;
-    private promiseService;
-    private columnUtil;
-    entries: ItemCache;
-    templates: ApiTemplateItemTypeMap;
-    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, columnHandler: ColumnHandler, itemCacheFactory: ItemCacheFactory, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter, keyService: KeyService, promiseService: PromiseInterface, columnUtil: ColumnUtil);
-    getItemId(itemEntry: ItemEntry): number;
-    getPromise(itemEntry: ItemEntry): any;
-    fetchItem(itemType: string, itemId: number, options: any): Promise<ItemEntry | TemplateResponseItemEntryMap>;
-    /**
-     *
-     * @param itemType
-     * @param itemIds
-     * @param options
-     * @returns {Promise<ItemEntry[]>}
-     *
-     * For every itemid find the status of the ItemEntry and resolve the promises so the result is
-     * a usable ItemEntry
-     */
-    fetchItems(itemType: any, itemIds: any, options: any): Promise<ItemEntry[]>;
-    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): Promise<ItemEntry>;
-    resolveLocal(itemEntry: ItemEntry, parent: any, template: any): TemplateResponseItemEntryMap;
-    resolveExpansion(itemEntry: any, columnExpansion: any, response: any): ItemEntry;
-    resolveRemote(itemEntry: any, columnInfo: any, response: any): ItemEntry;
-    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
-    getEntryStatus(itemType: string, itemId: number, options: any): EntryStatus<ItemEntry>;
-    getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
-    createDeferredEntry(itemType: string, itemId: number, requestColumns: any, deferRequest: any): ItemEntry;
-    createEntryStub(itemType: string, itemId: number): ItemEntry;
-    createEntry(itemId: number, initial: any, derived: any, columnInfo: any): ItemEntry;
-    resolveDeferredEntry(itemEntry: any, initial: any, derived: any, columns: any): ItemEntry;
-    /**
-     *
-     * @param itemType
-     * @param {BatchStatus} batchStatus
-     * @param requestColumns
-     * @param resolved
-     * @returns {ItemEntry[]}
-     *
-     * for every type of entry status there is in this batch request make sure the entries get resolved.
-     * then return a array of the resulting ItemEntryArray
-     */
-    batchResolve(itemType: any, batchStatus: BatchStatus, requestColumns: any, resolved: any): ItemEntry[] | Promise<any>;
-    cloneItem(newItemId: any, itemEntry: any, conversionMap?: any): any;
-    createConversionMap(itemType: string, itemId: number, extend: boolean, response: any): {
-        [x: string]: {
-            [x: number]: number;
-        };
-    };
-    createLocalEntries(parentType: string, localParentId: number, template: any, conversionMap: any): TemplateResponseLinkedItemEntryMap[];
-    createLocalEntry(itemId: number, template: any, modified: any, derived: any, parent?: any): ItemEntry;
-    extendConversionMap(conversionMap: any, links: any, apiResponse: any): void;
-    fetchTitle(itemType: string, itemId: number, deferRequest?: boolean): Promise<any>;
-    requestItem(itemType: string, itemId: number | number[], columns: any): Promise<ApiResponseProcessor>;
-    updateItemId(itemEntry: any, itemId: any): ItemEntry;
-    private setCreator(itemEntry);
-}
+import { ApiResponseProcessor, BatchStatus, ColumnHandler, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ENTRY_STATUS } from '../constants';
+import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ItemEntry } from '../models';
+import { ApiTemplateItemTypeMap, EntryStatus, ItemId, ItemIdConversionMap, ItemType, TemplateResponseItemEntryMap, TemplateResponseLinkedItemEntryMap } from '../types';
+export declare class ItemHandler {
+    private apiRequestService;
+    private errorHandler;
+    private itemEntryFactory;
+    private columnHandler;
+    private itemCacheFactory;
+    private batchStatusFactory;
+    private columnExpansionFactory;
+    private columnSetFactory;
+    private itemEntryService;
+    private keyService;
+    private promiseService;
+    private columnUtil;
+    entries: ItemCache;
+    templates: ApiTemplateItemTypeMap;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, columnHandler: ColumnHandler, itemCacheFactory: ItemCacheFactory, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface, columnUtil: ColumnUtil);
+    fetchItem(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): Promise<ItemEntry | TemplateResponseItemEntryMap>;
+    /**
+     *
+     * @param itemType
+     * @param itemIds
+     * @param options
+     * @returns {Promise<ItemEntry[]>}
+     *
+     * For every itemid find the status of the ItemEntry and resolve the promises so the result is
+     * a usable ItemEntry
+     */
+    fetchItems(itemType: any, itemIds: any, options: any, localItemCache: ItemCache): Promise<ItemEntry[]>;
+    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): Promise<ItemEntry>;
+    resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateResponseItemEntryMap;
+    resolveExpansion(itemEntry: any, columnExpansion: any, response: any): ItemEntry;
+    resolveRemote(itemEntry: any, columnInfo: any, response: any): any;
+    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<any>;
+    getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry>;
+    getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
+    /**
+     *
+     * @param itemType
+     * @param {BatchStatus} batchStatus
+     * @param requestColumns
+     * @param resolved
+     * @returns {ItemEntry[]}
+     *
+     * for every type of entry status there is in this batch request make sure the entries get resolved.
+     * then return a array of the resulting ItemEntryArray
+     */
+    batchResolve(itemType: any, batchStatus: BatchStatus, requestColumns: any, resolved: any, localItemCache: ItemCache): ItemEntry[] | Promise<any>;
+    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: any, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache): TemplateResponseLinkedItemEntryMap[];
+    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): Promise<any>;
+    requestItems(itemType: string, itemIds: ItemId[], columns: any): Promise<ApiResponseProcessor>;
+}

package/dist/dist/classes/ItemRequestService.d.ts

@@ -1,28 +1,22 @@
-import { ColumnExpansionFactory, ColumnSetFactory } from "../factories";
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from "../models";
-import { ApiResponseProcessor } from './ApiResponseProcessor';
-import { ColumnExpansion } from "./ColumnExpansion";
-import { ColumnHandler } from "./ColumnHandler";
-import { ItemEntryService } from "./ItemEntryService";
-import { ItemHandler } from "./ItemHandler";
-import { QueryService } from "./QueryService";
-export declare class ItemRequestService {
-    private apiRequestService;
-    private errorHandler;
-    private itemHandler;
-    private columnHandler;
-    private columnExpansionFactory;
-    private columnSetFactory;
-    private itemEntryService;
-    private queryService;
-    private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnHandler: ColumnHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, queryService: QueryService, promiseService: PromiseInterface);
-    requestItem(itemType: any, itemId: any, columns: any): Promise<ApiResponseProcessor>;
-    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<ApiResponseProcessor>;
-    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<ApiResponseProcessor>;
-    processExpansion(requestColumns: any, response: any, itemType: string, itemEntries: ItemEntry[]): ColumnExpansion;
-    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): Promise<ItemEntry[]>;
-    handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
-    processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): Promise<any>;
-}
+import { ApiResponseProcessor, ColumnExpansion, ItemHandler, QueryService } from '../classes';
+import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
+export declare class ItemRequestService {
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    private columnExpansionFactory;
+    private columnSetFactory;
+    private itemEntryFactory;
+    private queryService;
+    private promiseService;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseInterface);
+    requestItem(itemType: any, itemId: any, columns: any): Promise<ApiResponseProcessor>;
+    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<ApiResponseProcessor>;
+    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<ApiResponseProcessor>;
+    processExpansion(requestColumns: any, response: any, itemType: string, itemEntries: ItemEntry[]): ColumnExpansion;
+    processResponse(response: any, idArray: any, parent: any, columnInfo: any, columnExpansion?: any): Promise<ItemEntry[]>;
+    handleCachedItem(itemEntry: any, response: any, columnExpansion: ColumnExpansion): any;
+    processLinkResponse(response: any, parentType: any, parentIdArray: any, itemType: any, options: any): Promise<any>;
+}

package/dist/dist/classes/ItemResourceService.d.ts

@@ -1,7 +1,7 @@
-import { EditResource } from '../models';
-export declare class ItemResourceService {
-    constructor();
-    processOptions(options: any): any;
-    compareOptions(first: any, second: any): boolean;
-    isNewResource(resource: EditResource): boolean;
-}
+import { EditResource } from '../models';
+export declare class ItemResourceService {
+    constructor();
+    processOptions(options: any): any;
+    compareOptions(first: any, second: any): boolean;
+    isNewResource(resource: EditResource): boolean;
+}

package/dist/dist/classes/KeyService.d.ts

@@ -1,28 +1,25 @@
-export declare class KeyService {
-    NEW_PREFIX: string;
-    DUPLICATE_PREFIX: string;
-    NEW_KEYWORD: string;
-    DUPLICATE_KEYWORD: string;
-    seperator: string;
-    constructor();
-    getSingleKey(itemType: string, itemId: number | string): string;
-    getCollectionCacheKey(parentType: string, parentId: number, childType: string): string;
-    getCssKey(): any;
-    parseStateKey(stateKey: string): {
-        type: string;
-        template: string;
-        itemId?: undefined;
-    } | {
-        type: string;
-        itemId: string;
-        template?: undefined;
-    };
-    getDuplicateStateKey(itemId: string | number): string;
-    getNewStateKey(templateType: string): string;
-    getLocalId(): number;
-    getLocalDuplicateId(): number;
-    getRandomString(): string;
-    isLocalId(itemId: number | string): boolean;
-    isNewId(itemId: number | string): boolean;
-    isDuplicateId(itemId: number | string): boolean;
-}
+import { ItemId } from '../types';
+export declare class KeyService {
+    separator: string;
+    constructor();
+    getSingleKey(itemType: string, itemId: number | string): string;
+    getCollectionCacheKey(parentType: string, parentId: number, childType: string): string;
+    getCssKey(): any;
+    parseStateKey(stateKey: string): {
+        type: string;
+        template: string;
+        itemId?: undefined;
+    } | {
+        type: string;
+        itemId: string;
+        template?: undefined;
+    } | null;
+    getDuplicateStateKey(itemId: string | number): string;
+    getNewStateKey(templateType: string): string;
+    getLocalId(): ItemId;
+    getLocalDuplicateId(): ItemId;
+    getRandomString(): string;
+    isLocalId(itemId: ItemId | string): boolean;
+    isNewId(itemId: ItemId | string): boolean;
+    isDuplicateId(itemId: ItemId | string): boolean;
+}