@rentman/rm-core 1.7.2 → 1.7.4

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

@@ -2,7 +2,7 @@ import { ChangesProcessor, CollectionCache, ItemCache, LockService } from '../cl
 import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, ItemType, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
 export declare class LocalCache {
     private changesProcessor;
     private collectionCacheFactory;
@@ -18,70 +18,70 @@ export declare class LocalCache {
     readonly items: ItemCache;
     readonly collections: CollectionCache;
     readonly deferredCollections: CollectionCache;
-    rootItem: ItemEntry | undefined;
+    rootItem: ItemEntry<any> | undefined;
     tabRequestParameters: {};
     isSaving: boolean;
     private callbacks;
     private changesInterval;
     hasChanges: boolean;
     constructor(changesProcessor: ChangesProcessor, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string, defaultResourceLevel: number);
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         edit: true;
-    }, level?: number, isRoot?: boolean, isNew?: boolean): EditResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+    }, level?: number, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         remote: true;
-    }, level?: number, isRoot?: boolean, isNew?: boolean): RemoteViewResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, level?: number, isRoot?: boolean, isNew?: boolean): LocalViewResource;
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
+    }, level?: number, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, level?: number, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
         edit: true;
-    }, level?: number): EditResource[];
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
+    }, level?: number): Array<EditResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
         remote: true;
-    }, level?: number): RemoteViewResource[];
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface, level?: number): LocalViewResource[];
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): Array<RemoteViewResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface, level?: number): Array<LocalViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;
-    }, level?: number): CollectionEditResource<EditResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
         editCollection: true;
-    }, level?: number): CollectionEditResource<RemoteViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editCollection: true;
-    }, level?: number): CollectionEditResource<LocalViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
-    }, level?: number): CollectionViewResource<EditResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
-    }, level?: number): CollectionViewResource<RemoteViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface, level?: number): CollectionViewResource<LocalViewResource>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>, level?: number): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<EditResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
         editCollection: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editCollection: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<EditResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
-    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface, level?: number): CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>;
-    clearItem(itemResource: ItemResource): void;
-    clearItemEntry(itemEntry: ItemEntry): void;
-    clearCollection(collectionResource: CollectionResource): void;
+    }, level?: number): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
+    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>, level?: number): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    clearItem(itemResource: ItemResource<any>): void;
+    clearItemEntry(itemEntry: ItemEntry<any>): void;
+    clearCollection(collectionResource: CollectionResource<any>): void;
     clearDeferredCollections(): void;
     updateSingleItems(conversionMap: ItemIdConversionMap): void;
     revertChanges(): PromiseInterface<void>;
-    resetCollection(collectionEntry: CollectionEntry): void;
+    resetCollection(collectionEntry: CollectionEntry<any>): void;
     detectChanges(): boolean;
     private collectionHasChanges;
     isLockable(): boolean;
@@ -92,6 +92,6 @@ export declare class LocalCache {
     private executeCallbacks;
     enableChangesWatcher(): void;
     disableChangesWatcher(): void;
-    onDeactivateItem(itemEntry: ItemEntry): void;
-    onActivateItem(itemEntry: ItemEntry): void;
+    onDeactivateItem(itemEntry: ItemEntry<any>): void;
+    onActivateItem(itemEntry: ItemEntry<any>): void;
 }

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

@@ -22,11 +22,11 @@ export declare class LockService {
     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;
+    isLocked(itemEntry: ItemEntry<any>): boolean;
+    getMessage(itemEntry: ItemEntry<any>): undefined | string;
+    fetchCachedLock(itemEntry: ItemEntry<any>): PromiseInterface<undefined | LockToken>;
+    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<string>;
+    requestLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry<any>): boolean;
 }

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

@@ -6,13 +6,13 @@ export declare type ModuleChangesCompilationResult = {
     itemId: ItemId;
     items: ApiRequestItemMap;
 };
-export declare class ModuleChangesCompilation {
+export declare class ModuleChangesCompilation<RootItemEntryItemTypeType extends ItemType> {
     private rootItemEntry;
     private singleItemCache;
     private collectionCache;
     parentMap: any;
     destination: ApiRequestItemMap;
-    constructor(rootItemEntry: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache);
+    constructor(rootItemEntry: ItemEntry<RootItemEntryItemTypeType>, singleItemCache: ItemCache, collectionCache: CollectionCache);
     process(): ModuleChangesCompilationResult;
     private createParentMap;
     private processItems;

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

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

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

@@ -1,5 +1,5 @@
 import { CollectionResource, ItemResource } from '../models';
-declare type Resource = ItemResource | CollectionResource;
+declare type Resource = ItemResource<any> | CollectionResource<any>;
 export declare class ResourceCache<T extends Resource> {
     private cache;
     set<U extends T>(resource: U, level: number): U;

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

@@ -3,8 +3,8 @@ import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory, RequestColu
 import { ApiRequestServiceInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } 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 type SocketCollectionMap<ItemTypeType extends ItemType> = {
+    [itemId: number]: CollectionMatchResult<ItemTypeType>;
 };
 export declare class SocketMessageHandler {
     private apiFormatter;
@@ -21,21 +21,21 @@ export declare class SocketMessageHandler {
     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: {
+    createCollectionMap<ItemTypeType extends ItemType>(itemType: ItemTypeType, items: {
         [itemId: number]: any;
-    }, columns: ResponseColumn[]): SocketCollectionMap;
-    groupByCollectionId(itemType: ItemType, collectionMap: SocketCollectionMap): GroupedExtendedCollectionMatchResult;
-    getRequestColumns(itemType: ItemType, collectionMap: SocketCollectionMap): {
+    }, columns: ResponseColumn[]): SocketCollectionMap<ItemTypeType>;
+    groupByCollectionId<ItemTypeType extends ItemType>(itemType: ItemTypeType, collectionMap: SocketCollectionMap<ItemTypeType>): GroupedExtendedCollectionMatchResult<ItemTypeType>;
+    getRequestColumns<ItemTypeType extends ItemType>(itemType: ItemTypeType, collectionMap: SocketCollectionMap<ItemTypeType>): {
         [itemType: string]: ApiRequestColumns;
     };
-    deferEntry(itemEntry: ItemEntry): ItemEntry | PromiseInterface<ItemEntry>;
-    processMessage(body: any): PromiseInterface<GroupedExtendedCollectionMatchResult>;
-    processFunctionChangesResolve(body: any): PromiseInterface<void>;
-    handleResponse(itemType: ItemType, requestIds: ItemId[], requestColumns: ApiRequestColumns, response: ApiResponse, collectionMap: SocketCollectionMap): GroupedExtendedCollectionMatchResult;
+    deferEntry<T extends ItemEntry<any>>(itemEntry: T): T | PromiseInterface<T>;
+    processMessage<T extends SocketMessage['body']>(body: T): PromiseInterface<GroupedExtendedCollectionMatchResult<T['itemType']>>;
+    processFunctionChangesResolve<T extends SocketMessage['body']>(body: T): PromiseInterface<void>;
+    handleResponse<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestIds: ItemId[], requestColumns: ApiRequestColumns, response: ApiResponse, collectionMap: SocketCollectionMap<ItemTypeType>): GroupedExtendedCollectionMatchResult<ItemTypeType>;
     private isFunctionChangesResolveMessage;
     handleCreate(message: FunctionChangesResolveSocketMessage): PromiseInterface<void>;
     handleCreate(message: SocketMessage): PromiseInterface<null>;
     handleUpdate(message: SocketMessage): PromiseInterface<void>;
-    handleDelete(message: SocketMessage): PromiseInterface<void>;
+    handleDelete<T extends SocketMessage>(message: T): PromiseInterface<void>;
     handleLinkMove(): PromiseInterface<void>;
 }

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

@@ -5,7 +5,7 @@ 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: any) => boolean): boolean;
+export declare function filterArray<T>(source: T[], callback: (elem: T) => boolean): boolean;
 export declare function emptyArray(array: any): void;
 export declare function pathExists(source: any, path: any): boolean;
 export declare function createPath<T>(object: any, path: Array<number | string>, defaults: any[]): T;

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

@@ -1,8 +1,9 @@
 import { BatchStatus } from '../classes';
 import { PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
 import { ItemId, ItemType, PromiseInterface } from '../types';
 export declare class BatchStatusFactory {
     private promiseService;
     constructor(promiseService: PromiseLibraryInterface);
-    construct<T>(itemType: ItemType, getItemId: (entry: T) => ItemId, getPromise: (entry: T) => PromiseInterface<T>): BatchStatus<T>;
+    construct<ItemTypeType extends ItemType, T extends ItemEntry<ItemTypeType> | CollectionEntry<ItemTypeType>>(itemType: ItemTypeType, getItemId: (entry: T) => ItemId, getPromise: (entry: T) => PromiseInterface<T>): BatchStatus<ItemTypeType, T>;
 }

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

@@ -1,9 +1,10 @@
 import { ChangesCompilation, KeyService } from '../classes';
 import { CollectionEntry, ItemEntry } from '../models';
+import { ItemType } from '../types';
 import { CollectionCacheFactory } from './';
 export declare class ChangesCompilationFactory {
     private collectionCacheFactory;
     private keyService;
     constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService);
-    construct(singleItems: ItemEntry[], collections: CollectionEntry[]): ChangesCompilation;
+    construct(singleItems: Array<ItemEntry<ItemType>>, collections: Array<CollectionEntry<ItemType>>): ChangesCompilation;
 }

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

@@ -19,5 +19,5 @@ export declare class CollectionEntryFactory {
     promiseService: PromiseLibraryInterface;
     queryService: QueryService;
     constructor(collectionEntryService: CollectionEntryService, collectionResourceFactory: CollectionResourceFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
-    construct(itemType: ItemType, options: CollectionEntryOptionsInterface): CollectionEntry;
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptionsInterface): CollectionEntry<ItemTypeType>;
 }

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

@@ -1,7 +1,8 @@
 import { CollectionCache, CollectionMatcher } from '../classes';
 import { QueryMatcherFactory } from '../factories';
+import { ItemType } from '../types';
 export declare class CollectionMatcherFactory {
     private queryMatcherFactory;
     constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean): CollectionMatcher;
+    construct<ItemTypeType extends ItemType>(collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean): CollectionMatcher<ItemTypeType>;
 }

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

@@ -2,6 +2,7 @@ import { ChangesProcessor, KeyService, LocalCache, ResourceCache } from '../clas
 import { ItemResourceFactory } from '../factories';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
+import { ItemType } from '../types';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     exceptionHandler: ExceptionHandlerInterface;
@@ -9,24 +10,24 @@ export declare class CollectionResourceFactory {
     changesProcessor: ChangesProcessor;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    readonly cache: ResourceCache<CollectionResource>;
+    readonly cache: ResourceCache<CollectionResource<any>>;
     constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessor: ChangesProcessor, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;
-    }, level: number, localCache: LocalCache | null): CollectionEditResource<EditResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
         editCollection: true;
-    }, level: number, localCache: LocalCache | null): CollectionEditResource<RemoteViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editCollection: true;
-    }, level: number, localCache: LocalCache | null): CollectionEditResource<LocalViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         editItems: true;
-    }, level: number, localCache: LocalCache | null): CollectionViewResource<EditResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
+    }, level: number, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
         remoteItems: true;
-    }, level: number, localCache: LocalCache | null): CollectionViewResource<RemoteViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, level: number, localCache: LocalCache | null): CollectionViewResource<LocalViewResource>;
+    }, level: number, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, level: number, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
 }

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

@@ -4,5 +4,5 @@ import { ApiRequestColumns, ItemType, ResponseColumnMap } from '../types';
 export declare class ColumnExpansionFactory {
     private columnInfoFactory;
     constructor(columnInfoFactory: ColumnInfoFactory);
-    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ColumnExpansion;
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ColumnExpansion<ItemTypeType>;
 }

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

@@ -1,7 +1,7 @@
 import { ColumnInfo } from '../classes';
-import { ResponseColumn, RootColumnMap } from '../types';
+import { ItemType, ResponseColumn, RootColumnMap } from '../types';
 export declare class ColumnInfoFactory {
     constructor();
-    construct(apiColumn: ResponseColumn, parent: ColumnInfo | null): ColumnInfo;
-    constructFromRootMap(rootColumnMap: RootColumnMap, parent?: ColumnInfo | null): ColumnInfo[];
+    construct<ItemTypeType extends ItemType>(apiColumn: ResponseColumn, parent: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>;
+    constructFromRootMap<ItemTypeType extends ItemType>(rootColumnMap: RootColumnMap, parent?: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>[];
 }

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

@@ -6,6 +6,6 @@ export declare class ColumnSetFactory {
     private columnUtil;
     private columnInfoFactory;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory);
-    constructStub(itemType: ItemType, requestColumns: ApiRequestColumns): ColumnSet;
-    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet;
+    constructStub<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): ColumnSet<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
 }

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

@@ -1,6 +1,6 @@
 import { ColumnSubsetCache } from '../classes';
-import { ApiRequestColumns } from '../types';
+import { ApiRequestColumns, ItemType } from '../types';
 export declare class ColumnSubsetCacheFactory {
     constructor();
-    construct(requestColumns: ApiRequestColumns): ColumnSubsetCache;
+    construct<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
 }

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

@@ -1,11 +1,11 @@
 import { CollectionCache, CollectionHandler, CreateCompilation, CreateRequest, KeyService } from '../classes';
 import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestParameterMap } from '../types';
+import { CreateRequestParameterMap, ItemType } 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: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean): CreateRequest;
+    construct<ItemTypeType extends ItemType>(compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean): CreateRequest<ItemTypeType>;
 }

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

@@ -13,9 +13,9 @@ export declare class ItemEntryFactory {
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
     constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    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?: ItemIdConversionMap): ItemEntry;
-    constructDeferred(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry;
-    construct(itemId: ItemId, initial: FieldMap, derived: FieldMap, columnInfo: ColumnSet): ItemEntry;
+    constructStub<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, columnSetStub: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
+    constructLocalLinked<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, initial: FieldMap<ItemTypeType>, parent: EntryParentNull, columnSet: ColumnSet<ItemTypeType>, conversionMap: ItemIdConversionMap): ItemEntry<ItemTypeType>;
+    constructLocal<ItemTypeType extends ItemType>(itemId: ItemId, template: Template<ItemTypeType>, modified: FieldMap<ItemTypeType>, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet<ItemTypeType>, conversionMap?: ItemIdConversionMap): ItemEntry<ItemTypeType>;
+    constructDeferred<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemId: ItemId, initial: FieldMap<ItemTypeType>, derived: FieldMap, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
 }

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

@@ -1,29 +1,29 @@
 import { ApiFormatter, ChangesProcessor, LocalCache, LockService, ResourceCache } from '../classes';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { ItemOptionsInterface } from '../types';
-export declare type ResourceConstructor<T extends ItemResource> = (itemEntry: ItemEntry) => T;
+import { ItemOptionsInterface, ItemType } from '../types';
+export declare type ResourceConstructor<ItemTypeType extends ItemType, T extends ItemResource<ItemTypeType>> = (itemEntry: ItemEntry<ItemTypeType>) => T;
 export declare class ItemResourceFactory {
     apiFormatter: ApiFormatter;
     lockService: LockService;
     changesProcessor: ChangesProcessor;
     errorHandler: ErrorHandlerInterface;
     promiseService: PromiseLibraryInterface;
-    readonly cache: ResourceCache<ItemResource>;
+    readonly cache: ResourceCache<ItemResource<any>>;
     constructor(apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
-    getConstructor(options: ItemOptionsInterface & {
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
         edit: true;
-    }, level: number, localCache: LocalCache | null): ResourceConstructor<EditResource>;
-    getConstructor(options: ItemOptionsInterface & {
+    }, level: number, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
         remote: true;
-    }, level: number, localCache: LocalCache | null): ResourceConstructor<RemoteViewResource>;
-    getConstructor(options: ItemOptionsInterface, level: number, localCache: LocalCache | null): ResourceConstructor<LocalViewResource>;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+    }, level: number, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, level: number, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         edit: true;
-    }, level: number, localCache?: LocalCache | null, isNew?: boolean): EditResource;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+    }, level: number, localCache?: LocalCache | null, isNew?: boolean): EditResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
         remote: true;
-    }, level: number, localCache?: LocalCache | null, isNew?: boolean): LocalViewResource;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface, level: number, localCache?: LocalCache | null, isNew?: boolean): RemoteViewResource;
+    }, level: number, localCache?: LocalCache | null, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, level: number, localCache?: LocalCache | null, isNew?: boolean): RemoteViewResource<ItemTypeType>;
     private constructWithOptions;
 }

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

@@ -1,5 +1,6 @@
 import { CollectionCache, ItemCache, ModuleChangesCompilation } from '../classes';
 import { ItemEntry } from '../models';
+import { ItemType } from '../types';
 export declare class ModuleChangesCompilationFactory {
-    construct(rootItem: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache): ModuleChangesCompilation;
+    construct<ItemTypeType extends ItemType>(rootItem: ItemEntry<ItemTypeType>, singleItemCache: ItemCache, collectionCache: CollectionCache): ModuleChangesCompilation<ItemTypeType>;
 }

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

@@ -6,5 +6,5 @@ export declare class TemplateFactory {
     columnSetFactory: ColumnSetFactory;
     columnUtil: ColumnUtil;
     constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
-    construct(itemType: ItemType, response: ApiResponse, additionalColumns: ResponseColumnMap): Template;
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, response: ApiResponse, additionalColumns: ResponseColumnMap): Template<ItemTypeType>;
 }

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

@@ -1,14 +1,14 @@
 import { LocalCache } from '../classes';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionResource, CollectionResourceOptions, ItemResource, LocalViewResource } from '../models';
-import { FieldMap, ItemId, ItemIdConversionMap, PromiseInterface } from '../types';
-export declare class CollectionEditResource<T extends ItemResource = LocalViewResource> extends CollectionResource<T> {
-    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry, options: CollectionResourceOptions, level: number, localCache: LocalCache | null);
+import { FieldMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+export declare class CollectionEditResource<ItemTypeType extends ItemType = any, T extends ItemResource<ItemTypeType> = LocalViewResource<ItemTypeType>> extends CollectionResource<ItemTypeType, T> {
+    constructor(factory: CollectionResourceFactory, collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, level: number, localCache: LocalCache | null);
     save(): PromiseInterface<ItemIdConversionMap>;
-    moveItems(idArray: ItemId[], destination: CollectionResource, enableCallbacks?: boolean): T[];
+    moveItems(idArray: ItemId[], destination: CollectionResource<ItemTypeType>, enableCallbacks?: boolean): T[];
     removeItems(idArray: ItemId[], callOnRemove?: boolean): PromiseInterface<T[]>;
     removeItem(itemId: ItemId, callOnRemove?: boolean): PromiseInterface<T>;
-    addItems(valuesArray: FieldMap[], callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T[]>;
-    addItem(values: FieldMap, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T>;
+    addItems(valuesArray: Array<FieldMap<ItemTypeType>>, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T[]>;
+    addItem(values: FieldMap<ItemTypeType>, callOnAdd?: boolean, callOnActivate?: boolean): PromiseInterface<T>;
     clear(enableCallbacks: boolean): this["items"];
 }