@rentman/rm-core 1.4.0 → 1.5.1-1

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

@@ -1,4 +1,3 @@
-/// <reference types="moment" />
 import * as moment from 'moment';
 import { ColumnInfo } from '../classes';
 import { FieldMap } from '../types';

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

@@ -1,14 +1,16 @@
 import { ENTRY_STATUS } from '../constants';
 import { PromiseLibraryInterface } from '../interfaces';
-import { EntryStatus, EntryStatusMap, ItemId, PromiseInterface } from '../types';
+import { EntryStatus, EntryStatusMap, ItemId, ItemType, PromiseInterface } from '../types';
 export declare class BatchStatus<T> {
     private promiseService;
+    itemType: ItemType;
     getItemId: (itemEntry: T) => ItemId;
     getPromise: (itemEntry: T) => PromiseInterface<T>;
     readonly requestStatus: ENTRY_STATUS[];
     readonly remoteExpandStatus: ENTRY_STATUS[];
+    readonly localExpandStatus: ENTRY_STATUS[];
     entries: EntryStatusMap<T>;
-    constructor(promiseService: PromiseLibraryInterface, getItemId: (itemEntry: T) => ItemId, getPromise: (itemEntry: T) => PromiseInterface<T>);
+    constructor(promiseService: PromiseLibraryInterface, itemType: ItemType, getItemId: (itemEntry: T) => ItemId, getPromise: (itemEntry: T) => PromiseInterface<T>);
     add(entryStatus: EntryStatus<T>): void;
     hasEntries(statusArray: ENTRY_STATUS[]): boolean;
     hasRequests(): boolean;

package/dist/src/classes/ChangesCompilation.d.ts

@@ -2,6 +2,14 @@ import { CollectionCache, KeyService } from '../classes';
 import { CollectionCacheFactory } from '../factories';
 import { CollectionEntry, ItemEntry } from '../models';
 import { EntryParent, EntryParentNull, ItemEntryMap, ItemId, ItemType } from '../types';
+export declare type DeleteMapEntry = {
+    item: ItemEntry;
+    parent: EntryParentNull;
+};
+export declare type MoveMapEntry = {
+    item: ItemEntry;
+    parent: EntryParent;
+};
 export declare type CreateCompilation = {
     [parentType: string]: {
         [parentId: number]: ItemEntryMap;
@@ -13,7 +21,7 @@ export declare type DeleteCompilation = {
 export declare type UpdateCompilation = ItemEntryMap;
 export declare type MoveCompilation = {
     [parentType: string]: {
-        [parentId: number]: ItemEntry[];
+        [parentId: number]: MoveMapEntry[];
     };
 };
 export declare class ChangesCompilation {
@@ -36,8 +44,8 @@ export declare class ChangesCompilation {
     addUpdateEntry(itemEntry: ItemEntry): void;
     addCreateEntry(itemEntry: ItemEntry): void;
     containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
-    private createDeleteCompilation();
+    private createDeleteCompilation;
     postProcess(): void;
-    private processSingleItems();
-    private processCollections(collectionEntries);
+    private processSingleItems;
+    private processCollections;
 }

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

@@ -18,16 +18,16 @@ export declare class ChangesProcessor {
     constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, changesCompilationFactory: ChangesCompilationFactory, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
     buildMoveRequest(compilationEntries: any): {};
     getMapValue(itemType: ItemType, itemId: number | string, map: ItemIdConversionMap): ItemId | undefined;
-    private executeCreateRequests(changesCompilation, parameters, conversionMap, breakupByParent?, onAfterCreateCallback?);
-    private executeCreateRequest(requestResource, conversionMap);
-    private executeUpdateRequests(compilation, parameters);
-    private executeUpdateRequest(itemType, itemEntries, parameterMap);
-    private executeDeleteRequests(compilation);
-    private executeDeleteRequest(itemType, itemEntries);
-    private executeMoveRequests(compilation, conversionMap);
-    private processMoveResponse(compilationEntries);
-    private addCollectionMapEntry(collectionMap, parentId, itemEntry, value);
-    private forEachCollection(collectionMap, method);
-    private onItemsCreated(conversionMap, singleItems, collections);
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+    private executeMoveRequests;
+    private processMoveResponse;
+    private addCollectionMapEntry;
+    private forEachCollection;
+    private onItemsCreated;
     execute(singleItems: ItemEntry[], collections: CollectionEntry[], parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
 }

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

@@ -1,14 +1,14 @@
 import { QueryService } from '../classes';
 import { QueryParserFactory } from '../factories';
-import { ItemEntry } from '../models';
-import { ItemId } from '../types';
+import { CollectionEntryOptions, ItemEntry } from '../models';
+import { CollectionOptionsInterface, EntryParentNull, ItemId } from '../types';
 export declare class CollectionEntryService {
     private queryParserFactory;
     private queryService;
     constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
-    cloneOptions(options: any, parent: any): any;
+    cloneOptions(options: CollectionEntryOptions, parent: EntryParentNull): CollectionEntryOptions;
+    processOptions(options: CollectionOptionsInterface): CollectionEntryOptions;
     cloneQueryParams(parameters: any): {};
-    processOptions(options: any): any;
     createQuery(options: any): {
         object: any;
         string: any;

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

@@ -1,4 +1,4 @@
-import { PromiseInterface } from '../';
+import { CollectionEntryOptions, PromiseInterface } from '../';
 import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
@@ -36,14 +36,14 @@ export declare class CollectionHandler {
      */
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
     batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResource[]>;
-    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): PromiseInterface<ItemResourceItemIdMap>;
-    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
+    batchExtend(parentType: ItemType, itemType: ItemType, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): PromiseInterface<ItemResourceItemIdMap>;
+    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
     handleBatchResponse(batchStatus: BatchStatus<CollectionEntry>, itemEntryCompound: {
         columns: ColumnSet;
         columnExpansion?: ColumnExpansion;
         items?: ItemEntryParentIdMap;
     }, localItems: ItemEntryParentIdMap): CollectionEntryParentIdMap;
-    fetch(itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry>;
+    fetch(itemType: ItemType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry>;
     getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
     getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
         entry: CollectionEntry;
@@ -53,4 +53,5 @@ export declare class CollectionHandler {
     resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     isLocal(options: any): boolean;
+    private expandLocalItemEntries;
 }

package/dist/src/classes/CollectionMatcher.d.ts

@@ -19,12 +19,12 @@ export declare class CollectionMatcher {
     };
     constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean, callOnActivate: boolean);
     expand(itemEntry: ItemEntry): this;
-    private _expand(itemEntry, matchFunction);
+    private _expand;
     getCollectionsWithFittingItems(): CollectionEntry[];
     addToCollections(resultResource?: CollectionResource | null): ItemResource[] | null;
     removeFromCollections(resultResource?: CollectionResource | null): ItemResource[] | null;
     removeFromAndAddToCollections(): void;
-    private groupItemEntries(matches);
-    private groupItemIds(matches);
-    private hasFittingItems(matches);
+    private groupItemEntries;
+    private groupItemIds;
+    private hasFittingItems;
 }

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

@@ -1,5 +1,5 @@
-import { ItemResource } from '../models';
+import { CollectionResourceOptions, CollectionResourceOptionsInterface, ItemResource } from '../models';
 export declare class CollectionResourceService {
-    processOptions(options: any): any;
+    processOptions(options: CollectionResourceOptionsInterface): CollectionResourceOptions;
     getIdArray(itemResources: ItemResource[]): number[];
 }

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

@@ -15,7 +15,7 @@ export declare class ColumnCache {
     };
     containsAll(itemType: ItemType): boolean;
     getColumns(itemType: ItemType): ResponseColumnMap;
-    private retrieveColumns(itemType, requestColumns, requestAccumulator, responseAccumulator);
-    private retrieveColumn(itemType, requestColumn, requestAccumulator, responseAccumulator);
-    private getColumn(itemType, columnId);
+    private retrieveColumns;
+    private retrieveColumn;
+    private getColumn;
 }

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

@@ -8,11 +8,12 @@ export declare class ColumnExpansion {
     expansionMap: {
         [columnSetId: number]: ColumnExpansionResult | null;
     };
+    expansionMapSize: number;
     requestColumnsTrue: boolean;
     requestColumns: ApiRequestColumn[];
     constructor(columnInfoFactory: any, columnUtil: ColumnUtil, itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap);
     run(columnSet: ColumnSet): ColumnExpansionResult | null;
     aggregateRootColumns(): ColumnInfo[];
-    private expandRootColumnMap(columns, destination);
-    private processRootColumnMap(rootColumnMap, parent);
+    private expandRootColumnMap;
+    private processRootColumnMap;
 }

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

@@ -34,13 +34,13 @@ export declare class ColumnSet {
     resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
     expandRequestColumns(columns: ApiRequestColumns): void;
     isSupersetOf(columns: ApiRequestColumns): any;
-    private processResponseColumns(responseColumns);
-    private requestColumnsIsTrue(requestColumns);
-    private processRequestColumns(responseColumns, includeIdColumn);
-    private getRequestColumnInfo(requestColumn, itemType, parent, responseColumns);
-    private getColumnInfo(columnId, itemType, children, parent, responseColumns);
-    private getColumnSetExpansion(requestColumns, responseColumns);
-    private getMergedColumnSet(columnSetExpansion, requestColumnsTrue);
+    private processResponseColumns;
+    private requestColumnsIsTrue;
+    private processRequestColumns;
+    private getRequestColumnInfo;
+    private getColumnInfo;
+    private getColumnSetExpansion;
+    private getMergedColumnSet;
     merge(columnSet: ColumnSet): ColumnSet;
     expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
 }

package/dist/src/classes/ColumnSubsetCache.d.ts

@@ -0,0 +1,9 @@
+import { ColumnSet, ColumnUtil } from '../classes';
+import { ApiRequestColumns } from '../types';
+export declare class ColumnSubsetCache {
+    private columnUtil;
+    requestColumns: ApiRequestColumns;
+    private cache;
+    constructor(columnUtil: ColumnUtil, requestColumns: ApiRequestColumns);
+    run(columnSet: ColumnSet): boolean;
+}

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

@@ -16,5 +16,5 @@ export declare class CreateRequest {
     setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry): boolean;
     run(): CreateRequestEntry[];
     initializeRequest(): CreateRequestEntry;
-    private extendRequest(itemEntries, requestParentId, destination);
+    private extendRequest;
 }

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

@@ -1,18 +1,15 @@
-import { CollectionCache, CollectionEntryService, CollectionHandler, CollectionMatcher, CollectionResourceService, ItemCache, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
+import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
 import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptions, ItemResourcesItemTypeMap, ItemType, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap } from '../types';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, EditResource, ItemEntry, ItemResource, ItemResourceOptionsInterface } from '../models';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap } 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;
@@ -21,88 +18,53 @@ export declare class ItemAdministrator {
     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: PromiseLibraryInterface, queryService: QueryService);
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseLibraryInterface, queryService: QueryService);
     invalidateCache(): void;
     getCollectionMatcher(itemEntries: ItemEntry[], addToTab?: boolean): CollectionMatcher;
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
-    getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptions, isRoot?: boolean): PromiseInterface<ItemResource>;
-    getItemsById(itemType: string, itemIds: number[], options: any): PromiseInterface<ItemResource[]>;
-    getItemsByQuery(itemType: string, query: any, options: any): PromiseInterface<ItemResource[]>;
+    getItemById(itemType: ItemType, itemId: ItemId, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource>;
+    getItemsById(itemType: ItemType, itemIds: ItemId[], options?: ItemOptionsInterface): PromiseInterface<ItemResource[]>;
+    getItemsByQuery(itemType: ItemType, query: ApiQuery, options?: ItemOptionsInterface): PromiseInterface<ItemResource[]>;
     /**
      * 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 {PromiseInterface<ItemResource | TemplateItemEntryMap>}
      */
-    getNewResource(itemType: ItemType, options?: ItemOptions, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
-    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options?: ItemOptions, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
-    getItemByState(itemType: ItemType, stateKey: ItemId | string, options?: ItemOptions, isRoot?: boolean): PromiseInterface<ItemResource>;
-    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): PromiseInterface<CollectionResource>;
-    getCollectionFromDef(definition: any): PromiseInterface<CollectionResource>;
+    getNewResource(itemType: ItemType, options?: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource | TemplateItemResourceMap>;
+    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options?: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
+    getItemByState(itemType: ItemType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource>;
+    getCollectionDef(itemType: ItemType, options: CollectionOptionsInterface): CollectionDefinition;
+    getLinkCollectionsDef(linkType: ItemType, linkIdArray: ItemId[] | (() => ItemId[]), itemType: ItemType, linkField: string, options: CollectionOptionsInterface): LinkCollectionDefinition;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
+    getCollectionFromDef(definition: CollectionDefinition): PromiseInterface<CollectionResource>;
     /**
      * @deprecated, use `parent` in options
      */
-    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): PromiseInterface<CollectionResource>;
-    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): PromiseInterface<CollectionResourceParentIdMap>;
+    getLinkCollection(linkType: ItemType, linkId: ItemId, itemType: ItemType, options?: CollectionOptionsInterface): PromiseInterface<CollectionResource>;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap>;
     getLinkCollectionsFromDef(definition: any): PromiseInterface<CollectionResourceParentIdMap>;
-    getAllLinkCollections(linkType: string, itemType: string, options: any): PromiseInterface<CollectionResourceParentIdMap>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap>;
     cloneItem(itemResource: ItemResource, options: any): ItemResource;
     cloneCollection(collectionResource: CollectionResource, options: any, conversionMap: any): CollectionResource;
     saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
     getCurrentCollections(): CollectionCache;
     getCurrentItems(): ItemCache;
-    getModuleChanges(localCache?: LocalCache): {
-        itemType: string;
-        itemId: number;
-        items: {
-            [itemType: string]: {
-                [itemId: number]: {
-                    values?: any;
-                    links?: {
-                        [itemType: string]: number[];
-                    } | undefined;
-                };
-            };
-        };
-    };
-    addSingleItem(itemEntry: ItemEntry, options: ItemOptions, isRoot?: boolean, localCache?: LocalCache): ItemResource;
-    addSingleItems(itemEntries: ItemEntry[], options: ItemOptions): ItemResource[];
-    addCollection(collectionEntry: CollectionEntry, options: any): CollectionResource;
-    private createItemResources(itemType, itemEntries, options, localCache);
-    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptions, addToCollections?: boolean): ItemResourcesItemTypeMap;
-    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptions): Promise<ItemResourcesItemTypeMap>;
-    private constructOnItemsExpanded(itemType, itemEntries, itemOptions, localCache);
-    private expandAddToCollections(itemType, itemEntries, resultCollectionResource?, localCache?);
-    private getColumnSuperset(collectionEntries);
+    getModuleChanges(localCache?: LocalCache): import("./ModuleChangesCompilation").ModuleChangesCompilationResult;
+    addSingleItem(itemEntry: ItemEntry, options?: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): ItemResource;
+    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface): ItemResource[];
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface): CollectionResource;
+    private createItemResources;
+    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, addToCollections?: boolean): ItemResourcesItemTypeMap;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface): Promise<ItemResourcesItemTypeMap>;
+    private constructOnItemsExpanded;
+    private expandAddToCollections;
+    private getColumnSuperset;
     getLocalCache(): LocalCache;
     resetLocalCache(): void;
     addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
     removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
     saveLocal(itemResource: ItemResource): PromiseInterface<ItemResource>;
     updateItemIdMap(collectionMap: any, conversionMap: any): void;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: any, processOptions?: boolean): CollectionResource;
-    createItemResource(itemEntry: ItemEntry, options: any, isRoot: boolean): ItemResource;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): ItemResource;
     onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
     onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
 }

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

@@ -1,9 +1,9 @@
 import { QueryMatcherFactory } from '../factories';
 import { ItemEntry } from '../models';
-import { ItemEntryMap, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
+import { ItemEntryParentIdMap, ItemId, ItemType } from '../types';
 export declare class ItemCache {
     private queryMatcherFactory;
-    entries: ItemEntryMap;
+    private entries;
     constructor(queryMatcherFactory: QueryMatcherFactory);
     some(callback: (itemEntry: ItemEntry) => boolean): boolean;
     getByItemType(itemType: ItemType): ItemEntry[];

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

@@ -1,13 +1,13 @@
 import { KeyService } from '../classes';
 import { AuthInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ApiResponse, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ItemEntry, ItemEntryOptions } from '../models';
+import { ApiResponse, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
 export declare class ItemEntryService {
     private authInterface;
     private keyService;
-    undefinedItemError: string;
     constructor(authInterface: AuthInterface, keyService: KeyService);
-    processOptions(options?: any): any;
+    processOptions(options: ItemOptionsInterface): ItemEntryOptions;
+    createUnfoundRemoteItemError(): ItemError;
     createUnfoundLocalItemError(itemType: ItemType): {
         message: string;
     };

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

@@ -1,9 +1,9 @@
-import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
-import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
+import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry, Template } from '../models';
-import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemOptions, ItemType, PromiseInterface, ApiRequestColumns, TemplateItemEntryMap, LinkedItemEntryMap } from '../types';
+import { ItemEntry, ItemEntryOptions, Template } from '../models';
+import { ApiRequestColumns, ApiResponse, EntryParentNull, EntryStatus, ItemId, ItemIdConversionMap, ItemType, LinkedItemEntryMap, PromiseInterface, ResponseColumnMap, TemplateItemEntryMap } from '../types';
 export declare class ItemHandler {
     private apiFormatter;
     private apiRequestService;
@@ -11,6 +11,7 @@ export declare class ItemHandler {
     private columnExpansionFactory;
     private columnHandler;
     private columnSetFactory;
+    private columnSubsetCacheFactory;
     private columnUtil;
     private errorHandler;
     private itemCacheFactory;
@@ -23,55 +24,37 @@ export declare class ItemHandler {
     templates: {
         [itemType: string]: Template;
     };
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
-    fetchItem(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
-    fetchNewItem(itemType: ItemType, options: ItemOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
+    fetchItem(itemType: ItemType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    fetchNewItem(itemType: ItemType, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
+    createBatchStatus(itemType: ItemType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
+        batchStatus: BatchStatus<ItemEntry>;
+        success: boolean;
+    };
     /**
-     *
-     * @param itemType
-     * @param itemIds
-     * @param options
-     * @returns {PromiseInterface<ItemEntry[]>}
-     *
-     * For every itemid find the status of the ItemEntry and resolve the promises so the result is
+     * For every item ID find the status of the ItemEntry and resolve the promises so the result is
      * a usable ItemEntry
      */
-    fetchItems(itemType: ItemType, itemIds: ItemId[], options: any, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): PromiseInterface<ItemEntry>;
-    resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateItemEntryMap;
+    fetchItems(itemType: ItemType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    handleBatchResponse(batchStatus: BatchStatus<ItemEntry>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnMap | null, columnExpansion?: ColumnExpansion): PromiseInterface<boolean>;
+    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    private getColumnDifference;
+    resolveLocal(itemEntry: ItemEntry, parent: EntryParentNull, template: Template, localItemCache: ItemCache): TemplateItemEntryMap;
     resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
-    resolveRemote(itemEntry: ItemEntry, columnSet: ColumnSet, response: ApiResponse): ItemEntry | null;
-    resolveRemoteValues(itemEntry: ItemEntry, response: ApiResponse): ItemEntry | null;
-    getResponseFields(itemEntry: ItemEntry, columnSet: any, response: ApiResponse): {
-        initial: FieldMap;
-        derived: FieldMap;
-    } | null;
-    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
-    getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry> | null;
-    isColumnSuperset(itemEntry: ItemEntry, columns: ApiRequestColumns): any;
-    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: ItemType, batchStatus: BatchStatus<ItemEntry>, requestColumns: ApiRequestColumns, resolved: {
-        entries: ItemEntry[];
-        requests?: ApiResponseProcessor;
-    }): ItemEntry[] | PromiseInterface<any>;
+    private clearItem;
+    private resolveRemote;
+    private resolveRemoteValues;
+    private getResponseFields;
+    fetchTemplate(itemType: ItemType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
+    getEntryStatus(itemType: ItemType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache): EntryStatus<ItemEntry> | null;
+    getCachedEntryStatus(itemEntry: ItemEntry, columnSubsetCache: ColumnSubsetCache): ENTRY_STATUS;
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
     createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry) => boolean): LinkedItemEntryMap[];
-    expandLocalEntries(itemType: ItemType, itemEntries: ItemEntry[], columnSet: ColumnSet, localItemCache: ItemCache): Promise<ItemEntry[]>;
+    expandLocalEntries(itemType: ItemType, itemEntries: ItemEntry[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
     resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    private getDefaultValuesByColumn(itemEntries, rootColumn);
-    private getItemIdByColumn(itemEntry, column);
-    private fetchDerivedValuesByColumn(itemEntries, rootColumn, localItemCache);
+    private setDefaultValuesByColumn;
+    private getItemIdByColumn;
+    private fetchDerivedValuesByColumn;
     requestItem(itemEntry: ItemEntry, requestColumns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
     requestItems(itemType: ItemType, itemIds: ItemId[], columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
 }

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

@@ -2,7 +2,7 @@ import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QuerySer
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, ItemEntry } from '../models';
-import { ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiQuery, ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
 export declare class ItemRequestService {
     private apiRequestService;
     private errorHandler;
@@ -14,7 +14,7 @@ export declare class ItemRequestService {
     private promiseService;
     constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseLibraryInterface);
     requestItem(itemType: any, itemId: any, columns: any): PromiseInterface<ApiResponseProcessor>;
-    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): PromiseInterface<ApiResponseProcessor>;
+    requestItems(collectionEntry: CollectionEntry, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
     requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseInterface<ApiResponseProcessor>;
     processExpansion(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
     processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): PromiseInterface<ItemEntry[]>;

package/dist/src/classes/LocalCache.d.ts

@@ -1,8 +1,8 @@
-import { CollectionCache, ItemCache, ItemResourceService, LockService } from '../classes';
+import { CollectionCache, ItemCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptions, LocalCacheCallbackCondition, OnSaveCallback } from '../types';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource } from '../models';
+import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback } from '../types';
 export declare class LocalCache {
     private errorHandler;
     private lockService;
@@ -11,7 +11,6 @@ export declare class LocalCache {
     private changesProcessorFactory;
     private itemCacheFactory;
     private collectionResourceFactory;
-    private itemResourceService;
     private promiseService;
     id: string;
     items: ItemCache;
@@ -23,11 +22,13 @@ export declare class LocalCache {
     private callbacks;
     private changesInterval;
     hasChanges: boolean;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseLibraryInterface, id?: string);
-    createItemResource(itemEntry: ItemEntry, options: ItemOptions, isRoot?: boolean, isNew?: boolean): ItemResource;
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptions): ItemResource[];
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: any): CollectionResource;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: any): {};
+    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, promiseService: PromiseLibraryInterface, id?: string);
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): ItemResource;
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): ItemResource[];
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): {
+        [parentId: string]: CollectionResource;
+    };
     clearItem(itemResource: ItemResource): void;
     clearItemEntry(itemEntry: ItemEntry): void;
     clearCollection(collectionResource: CollectionResource): void;
@@ -36,13 +37,13 @@ export declare class LocalCache {
     revertChanges(): any;
     resetCollection(collectionEntry: CollectionEntry): void;
     detectChanges(): boolean;
-    private collectionHasChanges(collectionEntry);
+    private collectionHasChanges;
     isLockable(): boolean;
     save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
     onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
     onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
-    private executeCallbackEvent<T>(callbacks, execute, closeTab);
-    private executeCallbacks<T>(callbacks, execute);
+    private executeCallbackEvent;
+    private executeCallbacks;
     enableChangesWatcher(): void;
     disableChangesWatcher(): void;
     onDeactivateItem(itemEntry: any): void;

package/dist/src/classes/ModuleChangesCompilation.d.ts

@@ -14,8 +14,8 @@ export declare class ModuleChangesCompilation {
     destination: ApiRequestItemMap;
     constructor(rootItemEntry: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache);
     process(): ModuleChangesCompilationResult;
-    private createParentMap(itemCache);
-    private processItems(itemType, itemEntries, linkAccumulator);
-    private processItem(itemEntry);
-    private getItemsByParent(parentType, parentId);
+    private createParentMap;
+    private processItems;
+    private processItem;
+    private getItemsByParent;
 }