@rentman/rm-core 1.5.5 → 1.5.7-1

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

@@ -1,8 +1,8 @@
-import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
+import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, ModuleChangesCompilationResult, QueryService } from '../classes';
 import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
 import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
-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';
+import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, ItemResourceOptionsInterface, ViewResource } from '../models';
+import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
@@ -24,60 +24,138 @@ export declare class ItemAdministrator {
     fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
     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.
-     */
-    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>;
+    getItemsByQuery(itemType: ItemType, query: ApiQuery, options: ItemOptionsInterface & {
+        edit: true;
+    }): PromiseInterface<EditResource[]>;
+    getItemsByQuery(itemType: ItemType, query: ApiQuery, options: ItemOptionsInterface): PromiseInterface<ViewResource[]>;
+    getNewResource(itemType: ItemType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<{
+        main: EditResource;
+        linked: ItemResourcesItemTypeMap;
+    }>;
+    getNewResource(itemType: ItemType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource>;
+    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options: ItemOptionsInterface & {
+        edit: true;
+    }, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource>;
+    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ViewResource>;
+    getItemByState(itemType: ItemType, stateKey: ItemId | string, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean): PromiseInterface<EditResource>;
+    getItemByState(itemType: ItemType, stateKey: ItemId | string, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ViewResource>;
     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>;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
+        editCollection: true;
+        editItems: true;
+    }): PromiseInterface<CollectionEditResource<EditResource>>;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
+        editItems: true;
+    }): PromiseInterface<CollectionViewResource<EditResource>>;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface & {
+        editCollection: true;
+    }): PromiseInterface<CollectionEditResource>;
+    getCollection(itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionViewResource>;
     getCollectionFromDef(definition: CollectionDefinition): PromiseInterface<CollectionResource>;
     /**
      * @deprecated, use `parent` in options
      */
     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: 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;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<EditResource>>>;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ViewResource>>>;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface & {
+        editItems: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<EditResource>>>;
+    getLinkCollections(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ViewResource>>>;
+    getLinkCollectionsFromDef(definition: LinkCollectionDefinition): PromiseInterface<CollectionResourceParentIdMap>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<EditResource>>>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
+        editCollection: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ViewResource>>>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface & {
+        editItems: true;
+    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<EditResource>>>;
+    getAllLinkCollections(linkType: ItemType, itemType: ItemType, options: CollectionOptionsInterface): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ViewResource>>>;
+    cloneItem(itemResource: ItemResource, options: ItemOptionsInterface & {
+        edit: true;
+    }): EditResource;
+    cloneItem(itemResource: ItemResource, options: ItemOptionsInterface): ViewResource;
+    cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }, conversionMap: ItemIdConversionMap): CollectionEditResource<EditResource>;
+    cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
+        editItems: true;
+    }, conversionMap: ItemIdConversionMap): CollectionViewResource<EditResource>;
+    cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface & {
+        editCollection: true;
+    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ViewResource>;
+    cloneCollection(collectionResource: CollectionResource, options: CollectionOptionsInterface, conversionMap: ItemIdConversionMap): CollectionViewResource<ViewResource>;
+    saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
     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?: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): ItemResource;
-    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface): ItemResource[];
-    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface): CollectionResource;
-    private createItemResources(itemType, itemEntries, options, localCache);
-    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, addToCollections?: boolean): ItemResourcesItemTypeMap;
-    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface): Promise<ItemResourcesItemTypeMap>;
-    private constructOnItemsExpanded(itemType, itemEntries, itemOptions, localCache);
-    private expandAddToCollections(itemType, itemEntries, resultCollectionResource?, localCache?);
-    private getColumnSuperset(collectionEntries);
+    getModuleChanges(localCache?: LocalCache): ModuleChangesCompilationResult;
+    addSingleItem(itemEntry: ItemEntry, options: ItemResourceOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean, localCache?: LocalCache): EditResource;
+    addSingleItem(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): ViewResource;
+    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface & {
+        edit: true;
+    }): EditResource[];
+    addSingleItems(itemEntries: ItemEntry[], options: ItemResourceOptionsInterface): ViewResource[];
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+        editCollection: true;
+        editItems: true;
+    }): CollectionEditResource<EditResource>;
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }): CollectionViewResource<EditResource>;
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }): CollectionEditResource<ViewResource>;
+    addCollection(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface): CollectionViewResource<ViewResource>;
+    private createItemResources;
+    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface & {
+        edit: true;
+    }, addToCollections: boolean): ItemResourcesItemTypeMap<EditResource>;
+    processLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface, addToCollections: boolean): ItemResourcesItemTypeMap<ViewResource>;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface & {
+        edit: true;
+    }): PromiseInterface<ItemResourcesItemTypeMap<EditResource>>;
+    expandProcessLinkedItems(linkedEntries: LinkedItemEntryMap[], options: ItemOptionsInterface): PromiseInterface<ItemResourcesItemTypeMap<ViewResource>>;
+    private constructOnItemsExpanded;
+    private expandAddToCollections;
+    private getColumnSuperset;
     getLocalCache(): LocalCache;
     resetLocalCache(): void;
-    addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
-    removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
+    addToCollections(itemEntries: ItemEntry[], resultCollectionResource: CollectionResource<EditResource>): EditResource[];
+    addToCollections(itemEntries: ItemEntry[], resultCollectionResource: CollectionResource<ViewResource>): ViewResource[];
+    addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: null): null;
+    removeFromCollections<T extends CollectionResource = CollectionViewResource>(itemEntries: ItemEntry[], resultCollectionResource: T): T['items'];
+    removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: null): null;
     saveLocal(itemResource: ItemResource): PromiseInterface<ItemResource>;
-    updateItemIdMap(collectionMap: any, conversionMap: any): void;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): ItemResource;
+    updateItemIdMap(collectionMap: any, conversionMap: ConversionMap): void;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionEditResource<EditResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }): CollectionViewResource<EditResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }): CollectionEditResource<ViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionViewResource<ViewResource>;
+    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface & {
+        edit: true;
+    }, isRoot: boolean): EditResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemResourceOptionsInterface, isRoot: boolean): ViewResource;
     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,22 +1,23 @@
 import { QueryMatcherFactory } from '../factories';
 import { ItemEntry } from '../models';
-import { ItemEntryParentIdMap, ItemId, ItemType } from '../types';
+import { CollectionQuery, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
 export declare class ItemCache {
     private queryMatcherFactory;
     private entries;
     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[];
+    getByQuery(itemType: ItemType, query: CollectionQuery): ItemEntry[];
+    getLocalByQuery(itemType: ItemType, query: CollectionQuery): ItemEntry[];
     getByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): ItemEntry[];
     batchGetLocalByParent(parentType: ItemType, parentIds: ItemId[], itemType: ItemType, additionalQuery: any): ItemEntryParentIdMap;
     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;
-    updateItemId(itemEntry: ItemEntry, oldItemId: any): ItemEntry;
+    get(itemType: ItemType, itemId: string | ItemId): undefined | ItemEntry;
+    contains(itemType: ItemType, itemId: string | ItemId): boolean;
+    updateItemId(itemEntry: ItemEntry, oldItemId: string | ItemId): ItemEntry;
     clear(itemEntry: ItemEntry): boolean;
-    matchQuery(itemEntry: ItemEntry, query: any): boolean;
+    clearByItemId(itemType: ItemType, itemId: ItemId): boolean;
+    matchQuery(itemEntry: ItemEntry, query: CollectionQuery): boolean;
 }

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

@@ -17,8 +17,8 @@ export declare class ItemEntryService {
     batchExpandConversionMap(itemEntries: ItemEntry[], conversionMap: ItemIdConversionMap): ItemIdConversionMap;
     getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
     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";
+    getFullName(firstName: string, infix: string, lastName: string): string;
+    getTitleField(itemType: ItemType): string;
     getLocalDefaultValues(): FieldMap;
     hasLocalDefaultValue(columnId: string): boolean;
 }

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

@@ -38,13 +38,13 @@ export declare class ItemHandler {
     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(itemEntry, requestColumns);
+    private getColumnDifference;
     resolveLocal(itemEntry: ItemEntry, parent: EntryParentNull, template: Template, localItemCache: ItemCache): TemplateItemEntryMap;
     resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
-    private clearItem(itemEntry, localCache);
-    private resolveRemote(itemEntry, columnSet, response, localCache);
-    private resolveRemoteValues(itemEntry, response);
-    private getResponseFields(itemEntry, columnSet, response);
+    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;
@@ -52,9 +52,9 @@ export declare class ItemHandler {
     createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry) => boolean): LinkedItemEntryMap[];
     expandLocalEntries(itemType: ItemType, itemEntries: ItemEntry[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
     resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    private setDefaultValuesByColumn(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

@@ -13,9 +13,9 @@ export declare class ItemRequestService {
     private queryService;
     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>;
+    requestItem(itemType: ItemType, itemId: ItemId, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
     requestItems(collectionEntry: CollectionEntry, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestLinkItems(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): 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[]>;
     handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;

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

@@ -3,7 +3,7 @@ export declare class KeyService {
     separator: string;
     constructor();
     getSingleKey(itemType: string, itemId: number | string): string;
-    getCssKey(): any;
+    getCssKey(): string;
     parseStateKey(stateKey: string): StateKey | null;
     getDuplicateStateKey(itemId: string | number): string;
     getNewStateKey(templateType: string): string;

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

@@ -1,8 +1,8 @@
 import { CollectionCache, ItemCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback } from '../types';
+import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, ViewResource } from '../models';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
 export declare class LocalCache {
     private errorHandler;
     private lockService;
@@ -23,29 +23,53 @@ export declare class LocalCache {
     private changesInterval;
     hasChanges: boolean;
     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;
-    };
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean, isNew?: boolean): EditResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): ViewResource;
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
+        edit: true;
+    }): EditResource[];
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): ViewResource[];
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionEditResource<EditResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }): CollectionEditResource<ViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }): CollectionViewResource<EditResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionViewResource<ViewResource>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<EditResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<ViewResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }): CollectionResourceParentIdMap<CollectionViewResource<EditResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): CollectionResourceParentIdMap<CollectionViewResource<ViewResource>>;
     clearItem(itemResource: ItemResource): void;
     clearItemEntry(itemEntry: ItemEntry): void;
     clearCollection(collectionResource: CollectionResource): void;
     clearResources(isSubTabChange?: boolean): void;
-    updateSingleItems(conversionMap: any): void;
-    revertChanges(): any;
+    updateSingleItems(conversionMap: ItemIdConversionMap): void;
+    revertChanges(): PromiseInterface<void>;
     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;
+    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
     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;
-    onActivateItem(itemEntry: any): void;
+    onDeactivateItem(itemEntry: ItemEntry): void;
+    onActivateItem(itemEntry: ItemEntry): void;
 }

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

@@ -1,23 +1,32 @@
 import { KeyService } from '../classes';
 import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } from '../models';
+import { ItemId, ItemMap, PromiseInterface } from '../types';
+export declare type LockToken = {
+    isForeign: false;
+    id: number;
+    token: string;
+} | {
+    isForeign: true;
+    message: string;
+};
 export declare class LockService {
     private apiRequestService;
     private errorHandler;
     private keyService;
     private promiseService;
-    lockItems: {};
-    promises: {};
+    lockItems: ItemMap<LockToken>;
+    promises: ItemMap<PromiseInterface<LockToken>>;
     constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    getValue(itemEntry: ItemEntry, map: any): any;
-    setValue(itemEntry: ItemEntry, value: any, map: any): any;
-    getLocks(): {};
-    hasLock(lockTokenId: any): boolean;
-    isLocked(itemEntry: ItemEntry): any;
-    getMessage(itemEntry: any): any;
-    fetchCachedLock(itemEntry: ItemEntry): any;
-    fetchLock(itemEntry: ItemEntry): any;
-    requestLock(itemEntry: ItemEntry): any;
-    deleteLock(itemEntry: any): any;
-    clearLock(itemEntry: any): boolean;
+    private getValue;
+    private setValue;
+    getLocks(): this['lockItems'];
+    hasLock(lockTokenId: ItemId): boolean;
+    isLocked(itemEntry: ItemEntry): boolean;
+    getMessage(itemEntry: ItemEntry): undefined | string;
+    fetchCachedLock(itemEntry: ItemEntry): PromiseInterface<undefined | LockToken>;
+    fetchLock(itemEntry: ItemEntry): PromiseInterface<string>;
+    requestLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry): boolean;
 }

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;
 }

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

@@ -6,9 +6,9 @@ export declare class QueryMatcher {
     fields: FieldMap;
     parent: EntryParentNull;
     constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
-    private compareValues(value, queryValue);
-    matchQuery(query: any): boolean | string;
-    private matchLinkedToQuery(query);
-    private matchComplexQuery(query);
-    private matchSimpleQuery(value, query);
+    private compareValues;
+    matchQuery(query: any): boolean | 'maybe';
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
 }

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

@@ -1,16 +1,17 @@
+import { ApiQuery } from '../types';
 export declare class QueryParser {
-    query: any;
+    query: ApiQuery;
     parameters: any;
-    constructor(query: any, parameters?: any);
-    private processValue(value);
-    private compareParsedQueries(a, b);
-    parse(query?: any): any;
-    private parseSearchQuery(value);
-    private parseCustomQuery(custom, parameters);
-    private parseCustomParameters(parameters);
-    private parseSimpleQuery(key, value, comparator?);
-    private parseLinkedToQuery(linkedTo, query, reverse, not);
-    private parseComplexQuery(conditions, operator);
-    private parseConditions(conditions);
-    private formatValue(value);
+    constructor(query: ApiQuery, parameters?: object);
+    private compareParsedQueries;
+    parse(query?: ApiQuery): [object, string];
+    private parseSearchQuery;
+    private parseCustomQuery;
+    private parseCustomParameters;
+    private parseSimpleQuery;
+    private parseLinkedToQuery;
+    private parseComplexQuery;
+    private parseConditions;
+    private formatValue;
+    private processValue;
 }

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

@@ -1,19 +1,8 @@
+import { ApiQuery, EntryParentNull, ItemId } from '../types';
 export declare class QueryService {
     constructor();
-    addAndCondition(query: any, condition: any): {
-        conditions: any;
-    };
-    addOrCondition(query: any, condition: any): {
-        conditions: any;
-        operator?: undefined;
-    } | {
-        conditions: any[];
-        operator: string;
-    };
-    addParentCondition(query: any, parent: any): any;
-    createNotIn(idArray: any): {
-        comparator: string;
-        key: string;
-        value: any;
-    };
+    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
+    createNotIn(idArray: ItemId[]): ApiQuery;
 }

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

@@ -1,12 +1,14 @@
 import { ColumnSet, ColumnUtil } from '../classes';
 import { ApiRequestColumns } from '../types';
+declare type RequestColumnMap = {
+    [itemType: string]: ApiRequestColumns;
+};
 export declare class RequestColumnExpansion {
     private columnUtil;
     private columns;
     private columnSetIdMap;
     constructor(columnUtil: ColumnUtil);
     expand(columnSet: ColumnSet): void;
-    get(): {
-        [itemType: string]: ApiRequestColumns;
-    };
+    get(): RequestColumnMap;
 }
+export {};

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

@@ -1,23 +1,24 @@
 import { ApiFormatter, CollectionHandler, ItemHandler } from '../classes';
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, ItemResource } from '../models';
 import { ApiRequestColumns, ApiResponse, CollectionMatchResult, FieldMap, FunctionChangesResolveSocketMessage, GroupedExtendedCollectionMatchResult, ItemId, ItemType, PromiseInterface, ResponseColumn, SocketMessage } from '../types';
 export declare type SocketCollectionMap = {
     [itemId: number]: CollectionMatchResult;
 };
 export declare class SocketMessageHandler {
-    private promiseService;
+    private apiFormatter;
     private apiRequestService;
-    private itemHandler;
-    private itemEntryFactory;
     private collectionHandler;
-    private columnSetFactory;
     private columnExpansionFactory;
-    private requestColumnExpansionFactory;
-    private apiFormatter;
+    private columnSetFactory;
     private errorHandler;
-    constructor(promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, itemEntryFactory: ItemEntryFactory, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface);
+    private itemEntryFactory;
+    private itemHandler;
+    private localCacheManager;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemHandler: ItemHandler, localCacheManager: LocalCacheManagerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
     onMessageReceived(message: SocketMessage): any;
     formatMessageValues(values: any, columns: ResponseColumn[]): FieldMap;
     createCollectionMap(itemType: ItemType, items: {
@@ -31,7 +32,7 @@ export declare class SocketMessageHandler {
     processMessage(body: any): PromiseInterface<GroupedExtendedCollectionMatchResult>;
     processFunctionChangesResolve(body: any): PromiseInterface<void>;
     handleResponse(itemType: ItemType, requestIds: ItemId[], requestColumns: ApiRequestColumns, response: ApiResponse, collectionMap: SocketCollectionMap): GroupedExtendedCollectionMatchResult;
-    private isFunctionChangesResolveMessage(message);
+    private isFunctionChangesResolveMessage;
     handleCreate(message: FunctionChangesResolveSocketMessage): PromiseInterface<void>;
     handleCreate(message: SocketMessage): PromiseInterface<ItemResource[]>;
     handleUpdate(message: SocketMessage): PromiseInterface<void>;

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

@@ -1,13 +1,14 @@
-import { OptionsInterface } from '../types';
-export declare function instantiateOptions(options: OptionsInterface, values: object): void;
+export declare function instantiateOptions(options: {
+    [key: string]: any;
+}, values: object): void;
 export declare function shallowMerge(object: any, defaults: any): any;
 export declare function hasProperties(object: any): boolean;
 export declare function getFirstProperty(object: any): string | null;
 export declare function inArray(needle: any, haystack: any): boolean;
-export declare function filterArray<T>(source: T[], callback: (T) => boolean): boolean;
+export declare function filterArray<T>(source: T[], callback: (T: any) => boolean): boolean;
 export declare function emptyArray(array: any): void;
 export declare function pathExists(source: any, path: any): boolean;
-export declare function createPath(object: {}, path: Array<number | string>, defaults: any[]): any;
+export declare function createPath<T>(object: any, path: Array<number | string>, defaults: any[]): T;
 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;
@@ -17,7 +18,7 @@ export declare function isString(value: any): boolean;
 export declare function isNumber(value: any): boolean;
 export declare function isDate(value: any): boolean;
 export declare const isArray: (arg: any) => arg is any[];
-export declare function isFunction(value: any): boolean;
+export declare function isFunction<T>(value: any): value is T;
 export declare function isRegExp(value: any): boolean;
 export declare function isBoolean(value: any): boolean;
 export declare function isElement(node: any): boolean;

package/dist/src/constants.d.ts

@@ -7,7 +7,7 @@ export declare enum ENTRY_STATUS {
     EXPAND_LOCAL = "expand-local",
     PROMISED_EXPAND_LOCAL = "promised-expand-local",
     RESOLVE = "resolve",
-    RESOLVE_VALUES = "resolve-values",
+    RESOLVE_VALUES = "resolve-values"
 }
 export declare const ALL_PERMISSIONS = "7";
 export declare const COLUMN_SEPERATOR = ">";