@rentman/rm-core 1.3.6 → 1.3.8-1

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

@@ -30,7 +30,7 @@ export declare class ApiFormatter {
     formatRequestDate(value: any): any;
     formatRequestDuration(value: any): any;
     formatRequestColor(value: any): any;
-    getDefaultValue(columnType: any): false | 0 | moment.Moment | moment.Duration | "" | "0" | "#000000" | null;
+    getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
     isDefaultValue(columnType: any, value: any): boolean;
     clone(columnType: any, value: any): any;
     getCloneFunction(columnType: any): (date: any) => any;

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

@@ -1,7 +1,7 @@
 import { ApiResponseProcessor } from '../classes';
 import { ApiResponseProcessorFactory } from '../factories';
 import { ApiRequestServiceInterface } from '../interfaces';
-import { ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ItemId, ItemType, PromiseInterface } from '../types';
 export declare class ApiRequestService {
     private externalApiRequestService;
     private apiResponseProcessorFactory;
@@ -9,10 +9,12 @@ export declare class ApiRequestService {
     template(itemType: ItemType, params: any): PromiseInterface<ApiResponseProcessor>;
     create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
     delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
-    updateItems(itemType: ItemType, items: object, columns: any): PromiseInterface<ApiResponseProcessor>;
+    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
     requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: object): PromiseInterface<ApiResponseProcessor>;
-    columns(itemType: ItemType, columns: object, params?: any): PromiseInterface<ApiResponseProcessor>;
-    query(itemType: ItemType, query: object, columns: object, limit?: object): PromiseInterface<ApiResponseProcessor>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: {
+        [itemType: string]: ItemId[];
+    }): PromiseInterface<ApiResponseProcessor>;
+    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
+    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
     processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
 }

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

@@ -1,25 +1,50 @@
-import { CollectionCache } from '../classes';
+import { CollectionCache, KeyService } from '../classes';
 import { CollectionCacheFactory } from '../factories';
 import { CollectionEntry, ItemEntry } from '../models';
-import { EntryParent } from '../types';
+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;
+    };
+};
+export declare type DeleteCompilation = {
+    [itemType: string]: ItemEntry[];
+};
+export declare type UpdateCompilation = ItemEntryMap;
+export declare type MoveCompilation = {
+    [parentType: string]: {
+        [parentId: number]: MoveMapEntry[];
+    };
+};
 export declare class ChangesCompilation {
     private collectionCacheFactory;
+    private keyService;
     singleItems: ItemEntry[];
     compilation: {
-        create: {};
-        delete: {};
-        update: {};
-        move: {};
+        create: CreateCompilation;
+        delete: DeleteCompilation;
+        update: UpdateCompilation;
+        move: MoveCompilation;
     };
     collections: CollectionCache;
     private moveArray;
     private deleteMap;
-    constructor(collectionCacheFactory: CollectionCacheFactory, singleItems: ItemEntry[], collectionEntries: CollectionEntry[]);
+    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService, singleItems: ItemEntry[], collectionEntries: CollectionEntry[]);
     getDefaultParent(): EntryParent;
-    addMoveEntry(itemEntry: any): void;
-    addDeleteEntry(itemEntry: any, parentId: any, parentType: any): void;
-    addUpdateEntry(itemEntry: any): void;
-    addCreateEntry(itemEntry: any): void;
+    addMoveEntry(itemEntry: ItemEntry): void;
+    addDeleteEntry(itemEntry: ItemEntry, parent: EntryParentNull): void;
+    addUpdateEntry(itemEntry: ItemEntry): void;
+    addCreateEntry(itemEntry: ItemEntry): void;
+    containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
+    private createDeleteCompilation();
     postProcess(): void;
     private processSingleItems();
     private processCollections(collectionEntries);

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

@@ -2,29 +2,25 @@ import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler }
 import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, ItemEntry } from '../models';
-import { CreateRequestParameterMap, ItemIdConversionMap, PromiseInterface } from '../types';
+import { CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
 export declare class ChangesProcessor {
+    private apiFormatter;
     private apiRequestService;
-    private itemHandler;
-    private errorHandler;
-    private collectionHandler;
     private changesCompilationFactory;
-    private createRequestFactory;
-    private columnExpansionFactory;
-    private requestColumnExpansionFactory;
     private collectionEntryService;
-    private apiFormatter;
+    private collectionHandler;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private itemHandler;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseLibraryInterface);
-    getItemTypeUpdatePriority(itemType: any): 0 | 1 | 2;
-    isDocumentItemType(itemType: any): boolean;
-    isDocumentUpdate(compilation: any): boolean;
+    private requestColumnExpansionFactory;
+    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: any, itemId: any, map: any): any;
+    getMapValue(itemType: ItemType, itemId: number | string, map: ItemIdConversionMap): ItemId | undefined;
     private executeCreateRequests(changesCompilation, parameters, conversionMap, breakupByParent?, onAfterCreateCallback?);
     private executeCreateRequest(requestResource, conversionMap);
-    private prioritizeUpdateRequests(compilation, parameters);
-    private executeUpdateRequests(itemTypes, compilation, parameters);
+    private executeUpdateRequests(compilation, parameters);
     private executeUpdateRequest(itemType, itemEntries, parameterMap);
     private executeDeleteRequests(compilation);
     private executeDeleteRequest(itemType, itemEntries);

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

@@ -4,7 +4,7 @@ import { ENTRY_STATUS } from '../constants';
 import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemResource } from '../models';
-import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, RequestColumn } from '../types';
+import { ApiRequestColumn, CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType } from '../types';
 export declare class CollectionHandler {
     private errorHandler;
     private itemRequestService;
@@ -35,7 +35,7 @@ export declare class CollectionHandler {
      * @deprecated, use collectionMatcherFactory
      */
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
-    batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: RequestColumn[]): PromiseInterface<CollectionResource[]>;
+    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): PromiseInterface<CollectionEntryParentIdMap>;
     createStatusResource(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;

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

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

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

@@ -1,5 +1,5 @@
 import { ColumnUtil } from '../classes';
-import { ItemType, RequestColumns, ResponseColumn, ResponseColumnMap } from '../types';
+import { ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnMap } from '../types';
 export declare class ColumnCache {
     private columnUtil;
     cache: ResponseColumnMap;
@@ -8,10 +8,10 @@ export declare class ColumnCache {
     };
     constructor(columnUtil: ColumnUtil);
     setColumn(itemType: ItemType, responseColumn: ResponseColumn): any;
-    setColumns(itemType: ItemType, requestColumns: RequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
-    retrieve(itemType: ItemType, requestColumns: RequestColumns): {
+    setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
+    retrieve(itemType: ItemType, requestColumns: ApiRequestColumns): {
         cached: ResponseColumnMap;
-        missing: RequestColumns;
+        missing: ApiRequestColumns;
     };
     containsAll(itemType: ItemType): boolean;
     getColumns(itemType: ItemType): ResponseColumnMap;

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

@@ -1,5 +1,5 @@
 import { ColumnSet, ColumnUtil } from '../classes';
-import { ColumnExpansionResult, ItemType, RequestColumn, RequestColumns, ResponseColumnMap } from '../types';
+import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnExpansion {
     private columnUtil;
     itemType: ItemType;
@@ -8,7 +8,7 @@ export declare class ColumnExpansion {
         [columnSetId: number]: ColumnExpansionResult;
     };
     requestColumnsTrue: boolean;
-    requestColumns: RequestColumn[];
-    constructor(columnUtil: ColumnUtil, itemType: ItemType, requestColumns: RequestColumns, responseColumns: ResponseColumnMap);
+    requestColumns: ApiRequestColumn[];
+    constructor(columnUtil: ColumnUtil, itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap);
     run(columnSet: ColumnSet): ColumnExpansionResult | null;
 }

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

@@ -1,6 +1,6 @@
 import { ColumnCache, ColumnUtil } from '../classes';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemType, PromiseInterface, RequestColumns, ResponseColumn, ResponseColumnMap } from '../types';
+import { ApiRequestColumns, ItemType, PromiseInterface, ResponseColumn, ResponseColumnMap } from '../types';
 export declare class ColumnHandler {
     private apiRequestService;
     private errorHandler;
@@ -9,13 +9,13 @@ export declare class ColumnHandler {
     private columnUtil;
     constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, cache: ColumnCache, columnUtil: ColumnUtil);
     setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
-    setColumns(itemType: ItemType, requestColumns: RequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
+    setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
     fetchItemTypeTranslations(itemTypes: ItemType[]): PromiseInterface<{
         [itemType: string]: string;
     }>;
-    request(itemType: ItemType, columns: RequestColumns, params?: {
+    request(itemType: ItemType, columns: ApiRequestColumns, params?: {
         filter: boolean;
     }): PromiseInterface<ResponseColumnMap>;
-    fetch(itemType: ItemType, requestColumns: RequestColumns, params?: any): PromiseInterface<ResponseColumnMap>;
+    fetch(itemType: ItemType, requestColumns: ApiRequestColumns, params?: any): PromiseInterface<ResponseColumnMap>;
     fetchAll(itemType: ItemType): PromiseInterface<ResponseColumnMap>;
 }

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

@@ -1,13 +1,13 @@
 import { ColumnHandler, ColumnInfo, ColumnUtil } from '../classes';
 import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
-import { ColumnExpansionResult, RequestColumns, ResponseColumnMap } from '../types';
+import { ApiRequestColumns, ColumnExpansionResult, ResponseColumnMap } from '../types';
 export declare class ColumnSet {
     private columnHandler;
     private columnUtil;
     private columnInfoFactory;
     private columnSetFactory;
     itemType: any;
-    request: RequestColumns;
+    request: ApiRequestColumns;
     id: number;
     requestColumnsTrue: boolean;
     response: ResponseColumnMap;
@@ -26,17 +26,18 @@ export declare class ColumnSet {
     item: ColumnInfo[];
     notItem: ColumnInfo[];
     enableCaching: boolean;
-    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: any, request: RequestColumns);
+    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: any, request: ApiRequestColumns);
     toJSON(): {
         main: string[];
         derived: string[];
     };
     resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
-    expandRequestColumns(columns: RequestColumns): void;
-    isSupersetOf(columns: RequestColumns): any;
+    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);
-    expand(requestColumns: RequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
+    expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
 }

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

@@ -1,4 +1,4 @@
-import { RequestColumn, RequestColumns } from '../types';
+import { ApiRequestColumn, ApiRequestColumns } from '../types';
 export declare class ColumnUtil {
     constructor();
     getColumnPath(columns: any, renderAs: any): string;
@@ -26,27 +26,27 @@ export declare class ColumnUtil {
     hasLocationProperty(column: any, location: any): boolean;
     isEditableColumn(column: any): boolean;
     isSearchableColumn(column: any): boolean;
-    getDefaultWeight(column: any): 1 | 2 | 0.5 | 1.5;
+    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;
-    copyRequestColumns(columns: RequestColumns): RequestColumns;
-    copyRequestColumn(requestColumn: RequestColumn): RequestColumn;
+    copyRequestColumns(columns: ApiRequestColumns): ApiRequestColumns;
+    copyRequestColumn(requestColumn: ApiRequestColumn): ApiRequestColumn;
     /**
      * 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: RequestColumns, second: RequestColumns): {
-        merged: RequestColumns;
-        difference: RequestColumns;
+    mergeRequestColumns(first: ApiRequestColumns, second: ApiRequestColumns): {
+        merged: ApiRequestColumns;
+        difference: ApiRequestColumns;
     };
     mergeRequestColumn(requestColumn: any, destination: any): any;
     parseRequestColumn(requestColumn: any): {
         id: string;
-        children: RequestColumn[];
+        children: ApiRequestColumn[];
     };
     /**
      * Merges two sets of response columns.

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

@@ -1,6 +1,6 @@
-import { ChangesCompilation, CollectionCache, CollectionHandler, KeyService } from '../classes';
+import { CollectionCache, CollectionHandler, CreateCompilation, KeyService } from '../classes';
 import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestEntry, CreateRequestParameterMap } from '../types';
+import { CreateRequestEntry, CreateRequestParameterMap, ItemType } from '../types';
 export declare class CreateRequest {
     private collectionHandler;
     private collectionMatcherFactory;
@@ -11,9 +11,9 @@ export declare class CreateRequest {
     private parameterMap;
     private breakupByParent;
     requests: CreateRequestEntry[];
-    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: ChangesCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean);
+    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean);
     finalizeRequest(requestResource: CreateRequestEntry): CreateRequestEntry;
-    setRequestParent(parentType: any, requestResource: any): boolean;
+    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry): boolean;
     run(): CreateRequestEntry[];
     initializeRequest(): CreateRequestEntry;
     private extendRequest(itemEntries, requestParentId, destination);

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

@@ -75,7 +75,16 @@ export declare class ItemAdministrator {
     getModuleChanges(localCache?: LocalCache): {
         itemType: string;
         itemId: number;
-        items: any;
+        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[];

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

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

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

@@ -3,7 +3,7 @@ import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, 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, RequestColumns, TemplateItemEntryMap, TemplateLinkedItemEntryMap } from '../types';
+import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemOptions, ItemType, PromiseInterface, ApiRequestColumns, TemplateItemEntryMap, TemplateLinkedItemEntryMap } from '../types';
 export declare class ItemHandler {
     private apiFormatter;
     private apiRequestService;
@@ -48,7 +48,7 @@ export declare class ItemHandler {
     } | 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: RequestColumns): any;
+    isColumnSuperset(itemEntry: ItemEntry, columns: ApiRequestColumns): any;
     getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
     /**
      *
@@ -61,7 +61,7 @@ export declare class ItemHandler {
      * 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, requestColumns: RequestColumns, resolved: {
+    batchResolve(itemType: ItemType, batchStatus: BatchStatus, requestColumns: ApiRequestColumns, resolved: {
         entries: ItemEntry[];
         requests?: ApiResponseProcessor;
     }): ItemEntry[] | PromiseInterface<any>;
@@ -71,6 +71,6 @@ export declare class ItemHandler {
     private getDefaultValuesByColumn(itemEntries, rootColumn);
     private getItemIdByColumn(itemEntry, column);
     private fetchDerivedValuesByColumn(itemEntries, rootColumn, localItemCache);
-    requestItem(itemEntry: ItemEntry, requestColumns?: RequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestItems(itemType: ItemType, itemIds: ItemId[], columns: RequestColumns): PromiseInterface<ApiResponseProcessor>;
+    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 { ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface, RequestColumns } from '../types';
+import { ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
 export declare class ItemRequestService {
     private apiRequestService;
     private errorHandler;
@@ -16,7 +16,7 @@ export declare class ItemRequestService {
     requestItem(itemType: any, itemId: any, columns: any): PromiseInterface<ApiResponseProcessor>;
     requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): PromiseInterface<ApiResponseProcessor>;
     requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseInterface<ApiResponseProcessor>;
-    processExpansion(requestColumns: RequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
+    processExpansion(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
     processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): PromiseInterface<ItemEntry[]>;
     handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;
     processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;

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

@@ -19,6 +19,7 @@ export declare class LocalCache {
     collections: CollectionCache;
     deferredCollections: CollectionCache;
     tabRequestParameters: {};
+    isSaving: boolean;
     private callbacks;
     private changesInterval;
     hasChanges: boolean;

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

@@ -1,17 +1,19 @@
 import { CollectionCache, ItemCache } from '../classes';
 import { ItemEntry } from '../models';
+import { ApiRequestItemMap, ItemId, ItemType } from '../types';
+export declare type ModuleChangesCompilationResult = {
+    itemType: ItemType;
+    itemId: ItemId;
+    items: ApiRequestItemMap;
+};
 export declare class ModuleChangesCompilation {
     private rootItemEntry;
     private singleItemCache;
     private collectionCache;
     parentMap: any;
-    destination: any;
+    destination: ApiRequestItemMap;
     constructor(rootItemEntry: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache);
-    process(): {
-        itemType: string;
-        itemId: number;
-        items: any;
-    };
+    process(): ModuleChangesCompilationResult;
     private createParentMap(itemCache);
     private processItems(itemType, itemEntries, linkAccumulator);
     private processItem(itemEntry);

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

@@ -5,8 +5,8 @@ export declare function inArray(needle: any, haystack: any): boolean;
 export declare function filterArray<T>(source: T[], callback: (T) => boolean): boolean;
 export declare function emptyArray(array: any): void;
 export declare function pathExists(source: any, path: any): boolean;
-export declare function createPath(object: any, path: any, defaults: any): any;
-export declare function getPath(object: any, path: any, create?: boolean): any;
+export declare function createPath(object: {}, path: Array<number | string>, defaults: any[]): any;
+export declare function getPath(object: {}, path: Array<number | string>, create?: boolean): any;
 export declare function extend(dst: any, ...args: any[]): any;
 export declare function merge(dst: any, ...args: any[]): any;
 export declare function isObject(value: any): boolean;

package/dist/src/factories/ChangesCompilationFactory.d.ts

@@ -3,6 +3,7 @@ import { CollectionEntry, ItemEntry } from '../models';
 import { CollectionCacheFactory } from './';
 export declare class ChangesCompilationFactory {
     private collectionCacheFactory;
-    constructor(collectionCacheFactory: CollectionCacheFactory);
+    private keyService;
+    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: any);
     construct(singleItems: ItemEntry[], collections: CollectionEntry[]): ChangesCompilation;
 }

package/dist/src/factories/ChangesProcessorFactory.d.ts

@@ -2,17 +2,17 @@ import { ApiFormatter, ChangesProcessor, CollectionEntryService, CollectionHandl
 import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class ChangesProcessorFactory {
+    private apiFormatter;
     private apiRequestService;
-    private errorHandler;
-    private itemHandler;
-    private collectionHandler;
     private changesCompilationFactory;
-    private createRequestFactory;
-    private columnExpansionFactory;
-    private requestColumnExpansionFactory;
     private collectionEntryService;
-    private apiFormatter;
+    private collectionHandler;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private itemHandler;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseLibraryInterface);
+    private requestColumnExpansionFactory;
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, changesCompilationFactory: ChangesCompilationFactory, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
     construct(): ChangesProcessor;
 }

package/dist/src/factories/ColumnSetFactory.d.ts

@@ -1,11 +1,11 @@
 import { ColumnHandler, ColumnSet, ColumnUtil } from '../classes';
 import { ColumnInfoFactory } from '../factories';
-import { ItemType, RequestColumns, ResponseColumnMap } from '../types';
+import { ApiRequestColumns, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnSetFactory {
     private columnHandler;
     private columnUtil;
     private columnInfoFactory;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory);
-    constructStub(itemType: ItemType, requestColumns: RequestColumns): ColumnSet;
-    construct(itemType: ItemType, requestColumns: RequestColumns, responseColumns: ResponseColumnMap, enableCaching?: any, includeIdColumn?: any): ColumnSet;
+    constructStub(itemType: ItemType, requestColumns: ApiRequestColumns): ColumnSet;
+    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: any, includeIdColumn?: any): ColumnSet;
 }

package/dist/src/factories/CreateRequestFactory.d.ts

@@ -1,10 +1,11 @@
-import { CollectionHandler, CreateRequest, KeyService } from '../classes';
+import { CollectionCache, CollectionHandler, CreateCompilation, CreateRequest, KeyService } from '../classes';
 import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
+import { CreateRequestParameterMap } from '../types';
 export declare class CreateRequestFactory {
     private collectionHandler;
     private collectionMatcherFactory;
     private keyService;
     private requestColumnExpansionFactory;
     constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    construct(compilation: any, collectionEntries: any, parameterMap: any, breakupByParent?: any): CreateRequest;
+    construct(compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean): CreateRequest;
 }

package/dist/src/factories/ItemEntryFactory.d.ts

@@ -2,7 +2,7 @@ import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classe
 import { ColumnSetFactory } from '../factories';
 import { AuthInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, Template } from '../models';
-import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
+import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
 export declare class ItemEntryFactory {
     authInterface: AuthInterface;
     apiFormatter: ApiFormatter;
@@ -14,6 +14,6 @@ export declare class ItemEntryFactory {
     constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: ColumnSet): ItemEntry;
     constructLocalLinked(itemType: ItemType, itemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
     constructLocal(itemId: ItemId, template: Template, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet, conversionMap?: any): ItemEntry;
-    constructDeferred(itemType: ItemType, itemId: ItemId, requestColumns: RequestColumns, deferRequest: boolean): ItemEntry;
+    constructDeferred(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry;
     construct(itemId: ItemId, initial: FieldMap, derived: FieldMap, columnInfo: ColumnSet): ItemEntry;
 }

package/dist/src/interfaces/ApiRequestServiceInterface.d.ts

@@ -1,11 +1,11 @@
-import { ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestMoveItems, ItemId, ItemType, PromiseInterface } from '../types';
 export interface ApiRequestServiceInterface {
-    template(itemType: string, params: any): PromiseInterface<any>;
+    template(itemType: ItemType, params: any): PromiseInterface<any>;
     create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<any>;
     delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<any>;
-    updateItems(itemType: ItemType, items: object, columns: any): PromiseInterface<any>;
+    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: ApiRequestColumnMap): PromiseInterface<any>;
     requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<any>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: object): PromiseInterface<any>;
-    columns(itemType: ItemType, columns: object, params?: any): PromiseInterface<any>;
-    query(itemType: ItemType, query: object, columns: object, limit?: object): PromiseInterface<any>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: ApiRequestMoveItems): PromiseInterface<any>;
+    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<any>;
+    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<any>;
 }

package/dist/src/models/CollectionEntry.d.ts

@@ -1,7 +1,7 @@
 import { ColumnExpansion, ColumnInfo, ColumnSet, ItemCache } from '../classes';
 import { CollectionEntryFactory } from '../factories';
 import { CollectionResource, ItemEntry, ItemResource } from '../models';
-import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface, RequestColumns } from '../types';
+import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
 export declare class CollectionEntry {
     private factory;
     itemType: ItemType;
@@ -41,12 +41,12 @@ export declare class CollectionEntry {
     clear(resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     handleRemovedItems(filterFunction: (itemEntry: ItemEntry) => boolean, resultResource?: CollectionResource | null, updateInitial?: boolean, callOnRemove?: boolean): ItemResource[] | null;
     private handleRemovedItemCallbacks(removedFromInitial, removedFromModified, resultResource?, callOnRemove?);
-    expand(newColumns: RequestColumns): PromiseInterface<this>;
+    expand(newColumns: ApiRequestColumns): PromiseInterface<this>;
     extendQuery(callback: any): any;
     extend(queryCallback: any, collectionResource: any, callOnAdd?: any, updateInitial?: any): PromiseInterface<ItemResource[] | null>;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion): void;
-    expandRequestColumns(requestColumns: RequestColumns): void;
+    expandRequestColumns(requestColumns: ApiRequestColumns): void;
     getAddedItems(returnItemIds?: boolean): (number | ItemEntry)[];
     getRemovedItems(returnItemIds?: boolean): (number | ItemEntry)[];
     getUpdatedItems(): ItemEntry[];