@rentman/rm-core 6.2.4 → 6.3.0

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

@@ -1,6 +1,11 @@
 import moment from 'moment';
 import { ColumnInfo } from '../classes';
-import { FieldMap, ItemType } from '../types';
+import { ColumnIdTypeMap, FieldMap, ItemType, ResponseColumn } from '../types';
+declare type GetChangesResult<Fields extends FieldMap, key extends keyof Fields = string> = {
+    oldValue: Fields[key];
+    newValue: Fields[key];
+    column: ResponseColumn;
+};
 export declare class ApiFormatter {
     MOMENT_INVALID: string;
     SERVER_DATETIME_FORMAT: string;
@@ -20,14 +25,18 @@ export declare class ApiFormatter {
      * @description
      * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
      */
-    mergeCopyFields<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, changes: FieldMap<ItemTypeType>, newInitial: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
-    formatRequest<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    formatRequestLocal<ItemTypeType extends ItemType>(fields: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    mergeCopyFields<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(initial: FieldMap<ItemTypeType, Fields>, changes: FieldMap<ItemTypeType, Fields>, newInitial: FieldMap<ItemTypeType, Fields>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType, Fields>;
+    formatRequest<Fields extends FieldMap>(initial: Fields, modified: Fields, columns: Array<ColumnInfo<any>>): {
+        [columnId: string]: any;
+    };
+    formatRequestLocal<Fields extends FieldMap>(fields: Fields, columns: Array<ColumnInfo<any>>): {
+        [columnId: string]: any;
+    };
     hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>, includeReadOnlyColumns?: boolean): boolean;
-    getChanges<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    copyFields<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    getChanges<Fields extends FieldMap>(initial: Fields, modified: Fields, columns: Array<ColumnInfo<any>>): Array<GetChangesResult<Fields> | undefined>;
+    copyFields<Fields extends FieldMap>(source: Fields, destination: Fields, columns: Array<ColumnInfo<any>>): Fields;
+    shallowCopyFields<Fields extends FieldMap>(shallowSource: Fields, deepSource: Fields, destination: Fields, columns: Array<ColumnInfo<any>>): Fields;
+    setDefaultValues<ItemTypeType extends ItemType = any>(destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
     /**
      * @description
      * Compares the given fields, returns `true` when the fields are equal
@@ -53,3 +62,4 @@ export declare class ApiFormatter {
     cloneDate(date: moment.Moment): moment.Moment;
     identity<T>(input: T): T;
 }
+export {};

package/dist/types/classes/ApiResponseProcessor.d.ts

@@ -1,5 +1,5 @@
 import { ApiFormatter } from '../classes';
-import { FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
+import { ColumnIdTypeMap, FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
 export declare class ApiResponseProcessor<RequestItemType extends ItemType = any> {
     apiFormatter: ApiFormatter;
     response: any;
@@ -21,8 +21,8 @@ export declare class ApiResponseProcessor<RequestItemType extends ItemType = any
     fetchColumnArray(itemType: ItemType): ResponseColumn[];
     fetchDerivedObject(itemType: ItemType, itemId: ItemId, rootColumns: ResponseColumn[]): {};
     fetchDerivedValues(value: any, column: ResponseColumn, destination: any): void;
-    fetchObject<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId, includeLinks?: boolean): FieldMap<ItemTypeType> | undefined;
-    fetchObjectArray<ItemTypeType extends ItemType>(itemType: ItemTypeType, includeLinks?: boolean, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
+    fetchObject<Fields extends ColumnIdTypeMap, ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType, Fields> | undefined;
+    fetchObjectArray<ItemTypeType extends ItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
     fetchColumnsObject(): {
         [itemType: string]: ResponseColumn;
     };

package/dist/types/classes/ChangesDelta.d.ts

@@ -30,7 +30,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * - If the values don't contain an `id` a new one will be generated
      * - If you want to set a parent set the proper field, you can't pass it as a separate object
      */
-    setItemCreated<ItemTypeType extends ItemType>(itemType: ItemTypeType, values: FieldMap<ItemTypeType>): PromiseInterface<this>;
+    setItemCreated<ItemTypeType extends ItemType, Fields extends FieldMap<ItemTypeType>>(itemType: ItemTypeType, values: Fields): PromiseInterface<this>;
     /**
      * @description
      * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
@@ -39,7 +39,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      * - If the values don't contain an `id` a new one will be generated
      * - If you want to set a parent set the proper field, you can't pass it as a separate object
      */
-    setItemsCreated<ItemTypeType extends ItemType>(itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<this>;
+    setItemsCreated<ItemTypeType extends ItemType, Fields extends FieldMap<ItemTypeType>>(itemType: ItemTypeType, valuesArray: Fields[]): PromiseInterface<this>;
     /**
      * @description
      * Will create an {@link ItemEntry ItemEntry} when the delta is applied
@@ -51,7 +51,7 @@ export declare class ChangesDelta extends ChangesDeltaBase {
      *
      * @internal
      */
-    _setItemCreated<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): this;
+    _setItemCreated<ItemTypeType extends ItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): this;
     /**
      * @description
      * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally

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

@@ -10,7 +10,7 @@ export declare class CollectionEntryService {
     createUnfoundLocalCollectionError(itemType: ItemType): {
         message: string;
     };
-    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any>;
+    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any, any>;
     processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions;
     createQuery(query: ApiQuery): CollectionQuery;
     createQueryFromOptions(options: CollectionOptions): CollectionQuery;

package/dist/types/classes/ItemCreateService.d.ts

@@ -1,7 +1,7 @@
 import { ColumnSetFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
-import { EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../types';
+import { ColumnIdTypeMap, EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../types';
 import { ChangesDelta } from './ChangesDelta';
 import { ConversionMapService } from './ConversionMapService';
 import { KeyService } from './KeyService';
@@ -18,7 +18,7 @@ export declare class ItemCreateService {
      * @description
      * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
      */
-    createItemsFromValues<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType>>, parent?: EntryParentNull): PromiseInterface<void>;
-    processTemplate<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    createItemsFromValues<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType, Fields>>, parent?: EntryParentNull): PromiseInterface<void>;
+    processTemplate<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, Fields>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
     processTemplateLinkItems<ParentItemType extends ItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
 }

package/dist/types/classes/TemplateCache.d.ts

@@ -1,7 +1,7 @@
 import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
-import { EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { ColumnIdTypeMap, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
 import { ColumnHandler } from './ColumnHandler';
 import { ColumnUtil } from './ColumnUtil';
@@ -60,7 +60,7 @@ export declare class TemplateCache {
      *          );
      *  ```
      */
-    fetchTemplate<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType>>;
+    fetchTemplate<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType, Fields>>;
     private fetchTemplateById;
     private constructTemplateBuffer;
 }

package/dist/types/classes/cache/transaction/TransactionCache.d.ts

@@ -3,7 +3,7 @@ import { RmCore } from '../../../core';
 import { AbstractCacheDependencyInterface } from '../../../interfaces/AbstractCacheDependencyInterface';
 import { CollectionResource, ItemEntry, ItemEntryOptions, ItemResource } from '../../../models';
 import { CollectionOptionsInterface } from '../../../models/CollectionOptions';
-import { ApiQuery, ApiRequestColumn, ApiRequestColumns, CollectionDefinition, CollectionQuery, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
+import { ApiQuery, ApiRequestColumn, ApiRequestColumns, CollectionDefinition, CollectionQuery, CollectionResourceParentIdMap, ColumnIdTypeMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
 import { ModuleChangesCompilationResult } from '../../ModuleChangesCompilation';
@@ -247,7 +247,7 @@ export declare class TransactionCache extends AbstractCache {
     getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
     getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
     getCollectionFromDef<ItemTypeType extends ItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
+    getCollection<ItemTypeType extends ItemType, Fields extends FieldMap<ItemTypeType> = FieldMap<ItemTypeType>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType, Fields>>;
     getCollectionDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
     getLinkCollectionsDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, linkField: string, options: CollectionOptionsInterface<ItemTypeType>): LinkCollectionDefinition<ItemTypeType>;
     /**
@@ -280,7 +280,7 @@ export declare class TransactionCache extends AbstractCache {
      *
      * @param isRoot Sets the item as the root item of the transaction, new items will be linked to this item (if there's a connection in the LinkTree)
      */
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getItemById<ItemTypeType extends ItemType, Fields extends FieldMap<ItemTypeType> = FieldMap<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, Fields>>;
     /**
      * @description
      * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
@@ -316,7 +316,7 @@ export declare class TransactionCache extends AbstractCache {
      */
     getDelta(): InternalChangesDelta;
     createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType>>;
+    createItemResources<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType, Fields>>;
     processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
     createCollectionResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;

package/dist/types/classes/cache/transaction/TransactionItemHandler.d.ts

@@ -1,15 +1,15 @@
 import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ApiQuery, ApiRequestColumns, ColumnIdTypeMap, DeregFunction, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
 import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
 import { TransactionValidator } from './TransactionValidator';
-export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any> = {
-    initial: FieldMap<ItemTypeType>;
-    changes: FieldMap<ItemTypeType>;
+export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = {
+    initial: FieldMap<ItemTypeType, Fields>;
+    changes: FieldMap<ItemTypeType, Fields>;
 };
 /**
  * @description
@@ -22,11 +22,11 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private validator?;
     deletedItems: ItemTypeMap<ItemEntry[]>;
     itemChanges: {
-        [itemEntryId: number]: TransactionItemEntryChanges;
+        [itemEntryId: number]: TransactionItemEntryChanges<any, any>;
     };
     fieldChangeCallbacks: {
         [itemType: string]: {
-            [itemId: string]: FieldChangeCallback[];
+            [itemId: string]: Array<FieldChangeCallback<any, any>>;
         };
     };
     constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);

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

@@ -1,7 +1,7 @@
 import { CollectionEntryService, ColumnCache, KeyService, QueryService } from '../classes';
 import { CollectionEntry } from '../models/';
 import { CollectionOptionsInterface } from '../models/CollectionOptions';
-import { ItemType } from '../types/';
+import { ColumnIdTypeMap, ItemType } from '../types/';
 import { ColumnSetFactory } from './ColumnSetFactory';
 export declare class CollectionEntryFactory {
     private collectionEntryService;
@@ -10,5 +10,5 @@ export declare class CollectionEntryFactory {
     private queryService;
     private columnCache;
     constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, queryService: QueryService, columnCache: ColumnCache);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionEntry<ItemTypeType>;
+    construct<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType, Fields>): CollectionEntry<ItemTypeType, Fields>;
 }

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

@@ -2,7 +2,7 @@ import { ApiFormatter, ColumnUtil } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, ItemResource } from '../models';
-import { ItemType } from '../types';
+import { ColumnIdTypeMap, ItemType } from '../types';
 export declare class ItemResourceFactory {
     apiFormatter: ApiFormatter;
     errorHandler: ErrorHandlerInterface;
@@ -10,5 +10,5 @@ export declare class ItemResourceFactory {
     exceptionHandler: ExceptionHandlerInterface;
     columnUtil: ColumnUtil;
     constructor(apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil);
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, transaction: TransactionCache, isNew?: boolean): ItemResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any>(itemEntry: ItemEntry<ItemTypeType>, transaction: TransactionCache, isNew?: boolean): ItemResource<ItemTypeType, Fields>;
 }

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

@@ -1,22 +1,22 @@
 import { CollectionEntryService, ColumnCache, ColumnExpansion, ColumnSet, KeyService, QueryService } from '../classes';
 import { ColumnSetFactory } from '../factories';
-import { CollectionQuery, EntryParentNull, ItemType, PromiseInterface } from '../types';
+import { CollectionQuery, ColumnIdTypeMap, EntryParentNull, ItemType, PromiseInterface } from '../types';
 import { CollectionOptions } from './CollectionOptions';
-export declare class CollectionEntry<ItemTypeType extends ItemType = any> {
+export declare class CollectionEntry<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> {
     private collectionEntryService;
     private queryService;
     private columnSetFactory;
     private keyService;
     private columnCache;
     itemType: ItemTypeType;
-    options: CollectionOptions;
+    options: CollectionOptions<ItemTypeType, Fields>;
     id: number;
     parent: EntryParentNull;
     query: CollectionQuery;
     columns: ColumnSet<ItemTypeType>;
     reloadQueued: boolean;
     promise: PromiseInterface<this>;
-    constructor(collectionEntryService: CollectionEntryService, queryService: QueryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, columnCache: ColumnCache, itemType: ItemTypeType, options: CollectionOptions);
+    constructor(collectionEntryService: CollectionEntryService, queryService: QueryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, columnCache: ColumnCache, itemType: ItemTypeType, options: CollectionOptions<ItemTypeType, Fields>);
     isLocal(): boolean;
     queueReload(): void;
     expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;

package/dist/types/models/CollectionOptions.d.ts

@@ -1,18 +1,18 @@
 import { CollectionResource, ItemResource } from '../models';
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull, FieldChangeCallback, ItemType } from '../types';
-export declare type CollectionResourceCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isCalledAfterSocketUpdate: boolean) => void;
-export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType> = (itemResources: Array<ItemResource<ItemTypeType>>, collectionResource: CollectionResource<ItemTypeType>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
-export declare type CollectionOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionOptions<ItemTypeType>>;
-export declare class CollectionOptions<ItemTypeType extends ItemType = any> {
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ColumnIdTypeMap, EntryParentNull, FieldChangeCallback, ItemType } from '../types';
+export declare type CollectionResourceCallback<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any> = (itemResources: Array<ItemResource<ItemTypeType, Fields>>, collectionResource: CollectionResource<ItemTypeType, Fields>, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any> = (itemResources: Array<ItemResource<ItemTypeType, Fields>>, collectionResource: CollectionResource<ItemTypeType, Fields>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionOptionsInterface<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any> = Partial<CollectionOptions<ItemTypeType, Fields>>;
+export declare class CollectionOptions<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> {
     columns: ApiRequestColumns;
     query: ApiQuery | null;
     queryColumns: ApiRequestColumns;
     parent: EntryParentNull;
     limit: ApiRequestLimit | null;
-    onAdd: CollectionResourceOnAddCallback<ItemTypeType>;
-    onRemove: CollectionResourceCallback<ItemTypeType>;
+    onAdd: CollectionResourceOnAddCallback<ItemTypeType, Fields>;
+    onRemove: CollectionResourceCallback<ItemTypeType, Fields>;
     onChange: FieldChangeCallback;
     custom: any;
     callOnAddWithInitialItems: boolean;
-    constructor(values: CollectionOptionsInterface<ItemTypeType>);
+    constructor(values: CollectionOptionsInterface<ItemTypeType, Fields>);
 }

package/dist/types/models/CollectionResource.d.ts

@@ -2,15 +2,15 @@ import { TransactionCache } from '../classes/cache/transaction/TransactionCache'
 import { ChangesDeltaResult } from '../classes/ChangesDeltaBase';
 import { CollectionResourceFactory } from '../factories';
 import { CollectionEntry, CollectionOptions, ItemEntry, ItemResource } from '../models';
-import { ApiRequestLimit, CompareFieldCallback, DeregFunction, FieldMap, ItemId, ItemResourceItemIdMap, ItemType, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../types';
-export declare class CollectionResource<ItemTypeType extends ItemType = any> {
+import { ApiRequestLimit, ColumnIdTypeMap, CompareFieldCallback, DeregFunction, FieldMap, ItemId, ItemResourceItemIdMap, ItemType, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../types';
+export declare class CollectionResource<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> {
     protected factory: CollectionResourceFactory;
-    options: CollectionOptions<ItemTypeType>;
+    options: CollectionOptions<ItemTypeType, Fields>;
     transaction: TransactionCache;
-    entry: CollectionEntry<ItemTypeType>;
+    entry: CollectionEntry<ItemTypeType, Fields>;
     columns: ResponseColumnItemTypeMap;
-    items: Array<ItemResource<ItemTypeType>>;
-    protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType>>;
+    items: Array<ItemResource<ItemTypeType, Fields>>;
+    protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType, Fields>>;
     private fieldChangeDeregFns;
     private readonly onChangeCallbacks;
     private readonly onAddCallbacks;
@@ -20,12 +20,12 @@ export declare class CollectionResource<ItemTypeType extends ItemType = any> {
      * We store the ItemIds of the items that were taking out the collections so that we can include those when doing a not-in when having a limit
      */
     private removedItemIds;
-    constructor(factory: CollectionResourceFactory, options: CollectionOptions<ItemTypeType>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: Array<ItemEntry<ItemTypeType>>);
+    constructor(factory: CollectionResourceFactory, options: CollectionOptions<ItemTypeType, Fields>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: Array<ItemEntry<ItemTypeType>>);
     onConstruct(): void;
     setLimit(newLimit: number | ApiRequestLimit): void;
-    onAdd(callback: OnAddCallback): DeregFunction;
-    onChange(callback: OnChangeCallback): DeregFunction;
-    onRemove(callback: OnRemoveCallback): DeregFunction;
+    onAdd(callback: OnAddCallback<ItemTypeType, Fields>): DeregFunction;
+    onChange(callback: OnChangeCallback<ItemTypeType, Fields>): DeregFunction;
+    onRemove(callback: OnRemoveCallback<ItemTypeType, Fields>): DeregFunction;
     __clear(): void;
     /**
      * @deprecated
@@ -34,29 +34,29 @@ export declare class CollectionResource<ItemTypeType extends ItemType = any> {
     moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
     removeItems(idArray: ItemId[]): PromiseInterface<ChangesDeltaResult>;
     removeItem(itemId: ItemId): PromiseInterface<ChangesDeltaResult>;
-    addItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
+    addItems(valuesArray: Array<Partial<Fields>>): PromiseInterface<ChangesDeltaResult>;
     addItem(values: FieldMap<ItemTypeType>): PromiseInterface<ChangesDeltaResult>;
     getIdArray(): ItemId[];
-    getItemById(itemId: number): ItemResource<ItemTypeType>;
-    addItemResources(itemEntriesToBeAdded: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): Array<ItemResource<ItemTypeType>>;
+    getItemById(itemId: number): ItemResource<ItemTypeType, Fields>;
+    addItemResources(itemEntriesToBeAdded: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): Array<ItemResource<ItemTypeType, Fields>>;
     /**
      * @description
      * Returns the {@link ItemResource ItemResources} that where removed from the {@link CollectionResource collection}.
      * Filters on {@link ItemResource ItemResource}.{@link ItemEntry entry} === {@link ItemEntry entry}
      */
-    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isCalledAfterSocketUpdate: boolean): Array<ItemResource<ItemTypeType>>;
-    callOnAdd(itemResources: Array<ItemResource<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
-    callOnChange(itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback, fields: FieldMap<ItemTypeType>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType>): void;
-    callOnRemove(itemResources: Array<ItemResource<ItemTypeType>>, isCalledAfterSocketUpdate: boolean): void;
-    forEach(callback: (itemResource: ItemResource<ItemTypeType>) => void): void;
-    filter(callback: (itemResource: ItemResource<ItemTypeType>) => boolean): Array<ItemResource<ItemTypeType>>;
-    first(callback: (itemResource: ItemResource<ItemTypeType>) => boolean): ItemResource<ItemTypeType> | null;
-    some(callback: (itemResource: ItemResource<ItemTypeType>) => boolean): boolean;
-    groupBy(argument: string | ((itemResource: ItemResource<ItemTypeType>) => string | null)): {
-        [key: string]: Array<ItemResource<ItemTypeType>>;
+    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isCalledAfterSocketUpdate: boolean): Array<ItemResource<ItemTypeType, Fields>>;
+    callOnAdd(itemResources: Array<ItemResource<ItemTypeType, Fields>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
+    callOnChange(itemEntry: ItemEntry<ItemTypeType>, compareField: CompareFieldCallback<Fields>, fields: FieldMap<ItemTypeType, Fields>, isCalledAfterSocketUpdate: boolean, previous: FieldMap<ItemTypeType, Fields>): void;
+    callOnRemove(itemResources: Array<ItemResource<ItemTypeType, Fields>>, isCalledAfterSocketUpdate: boolean): void;
+    forEach(callback: (itemResource: ItemResource<ItemTypeType, Fields>) => void): void;
+    filter(callback: (itemResource: ItemResource<ItemTypeType, Fields>) => boolean): Array<ItemResource<ItemTypeType, Fields>>;
+    first(callback: (itemResource: ItemResource<ItemTypeType, Fields>) => boolean): ItemResource<ItemTypeType, Fields> | null;
+    some(callback: (itemResource: ItemResource<ItemTypeType, Fields>) => boolean): boolean;
+    groupBy(argument: string | ((itemResource: ItemResource<ItemTypeType, Fields>) => string | null)): {
+        [key: string]: Array<ItemResource<ItemTypeType, Fields>>;
     };
-    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType>) => U)): U[];
-    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType>, value: U) => U, value: U): U;
+    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType, Fields>) => U)): U[];
+    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType, Fields>, value: U) => U, value: U): U;
     /**
      * @description
      * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}

package/dist/types/models/ItemResource.d.ts

@@ -1,8 +1,8 @@
 import { TransactionCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry } from '../models';
-import { EntryParentNull, FieldMap, ItemType, PromiseInterface, ResponseColumn } from '../types';
-export declare class ItemResource<ItemTypeType extends ItemType = any> {
+import { ColumnIdTypeMap, EntryParentNull, FieldMap, ItemType, PromiseInterface, ResponseColumn } from '../types';
+export declare class ItemResource<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> {
     protected readonly factory: ItemResourceFactory;
     readonly entry: ItemEntry<ItemTypeType>;
     protected readonly _isNew: boolean;
@@ -10,16 +10,16 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
     columns: {
         [columnId: string]: ResponseColumn;
     };
-    fields: FieldMap<ItemTypeType>;
-    initial: Readonly<FieldMap<ItemTypeType>>;
+    fields: FieldMap<ItemTypeType, Fields>;
+    initial: Readonly<FieldMap<ItemTypeType, Fields>>;
     constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, _isNew: boolean, transaction: TransactionCache);
     onConstruct(): void;
     /**
      * @description
      * Updates the fields of the item and calls onChange, when updating many fields of many items it's better to create a {@link ChangesDelta ChangesDelta} yourself so all changes can be applied at once
      */
-    setFields(values: FieldMap<ItemTypeType>): PromiseInterface<this>;
-    copyFields(destination?: FieldMap<ItemTypeType>): FieldMap<ItemTypeType>;
+    setFields(values: Partial<Fields>): PromiseInterface<this>;
+    copyFields(destination?: FieldMap<ItemTypeType>): Fields;
     /**
      * Fetches the ItemResource's parent with the current fields
      *
@@ -33,7 +33,7 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
      * @deprecated
      * Use {@link TransactionCache.applyChangesDelta transaction.applyChangesDelta} instead
      */
-    callOnChange(previous: FieldMap<ItemTypeType>): void;
+    callOnChange(previous: Fields): void;
     /**
      * @description
      * Utility function to easily check if a field is changed.
@@ -50,7 +50,7 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
      *     }
      * }
      */
-    compareItemField(columnId: keyof FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): boolean;
+    compareItemField(columnId: keyof Fields, previous: Fields): boolean;
     hasChanges(): boolean;
     setTransactionParameters(parameters: any): void;
     /**
@@ -61,7 +61,7 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
     isLocal(): boolean;
     toJSON(): {
         columns: string[];
-        fields: FieldMap<ItemTypeType>;
+        fields: Fields;
         entry: ItemEntry<ItemTypeType>;
     };
     /**
@@ -80,5 +80,5 @@ export declare class ItemResource<ItemTypeType extends ItemType = any> {
      * @remark
      * Assumes the derived item's values are already cached
      */
-    getDerivedValues(columnPath: string[]): Readonly<FieldMap> | undefined;
+    getDerivedValues<DerivedFields extends FieldMap = any>(columnPath: string[]): Readonly<DerivedFields> | undefined;
 }

package/dist/types/models/Template.d.ts

@@ -1,11 +1,11 @@
 import { ColumnSet } from '../classes';
 import { TemplateFactory } from '../factories';
-import { ApiRequestColumnMap, ApiResponse, FieldMap, ItemType, ResponseColumnItemTypeMap } from '../types';
-export declare class Template<ItemTypeType extends ItemType = any> {
+import { ApiRequestColumnMap, ApiResponse, ColumnIdTypeMap, FieldMap, ItemType, ResponseColumnItemTypeMap } from '../types';
+export declare class Template<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> {
     itemType: ItemTypeType;
     response: ApiResponse;
     responseColumns: ResponseColumnItemTypeMap;
     columns: ColumnSet<ItemTypeType>;
     constructor(factory: TemplateFactory, itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap);
-    getFields(): FieldMap<ItemTypeType>;
+    getFields(): FieldMap<ItemTypeType, Fields>;
 }

package/dist/types/types/ItemTypesCollection.d.ts

@@ -13,9 +13,8 @@ export declare type EntryParentNull = EntryParent | null;
  * @description
  * Used for fields that belong to a specific itemType
  */
-export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
-    [key: string]: any;
-};
+export declare type FieldMap<_ItemTypeType extends ItemType = any, Values = ColumnIdTypeMap> = Values;
+export declare type ColumnIdTypeMap<Fields extends object = any> = Fields;
 export declare type ItemOptionsInterface = ItemEntryOptionsInterface;
 export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
@@ -115,10 +114,10 @@ export interface FunctionChangesResolveSocketMessage extends SocketMessage {
         [key: string]: any;
     };
 }
-export declare type ItemResourceItemIdMap<T extends ItemResource<any> = ItemResource<any>> = {
+export declare type ItemResourceItemIdMap<T extends ItemResource = ItemResource> = {
     [itemId: number]: T;
 };
-export declare type ItemResourcesItemTypeMap<T extends ItemResource<any> = ItemResource<any>> = {
+export declare type ItemResourcesItemTypeMap<T extends ItemResource = ItemResource> = {
     [itemType: string]: T[];
 };
 export declare type ItemId = number;
@@ -230,34 +229,34 @@ export declare type ApiLinkTree = {
  * @description
  * Callback to determine if an item should be included in the create delta, return `false` to exclude the item
  */
-export declare type FilterItemEntryCallback = <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>) => boolean;
-export declare type ModifyFieldsCallback = <ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType>, itemIdConversionMap?: ItemIdConversionMap) => void;
+export declare type FilterItemEntryCallback = <ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType, Fields>) => boolean;
+export declare type ModifyFieldsCallback = <ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any>(itemType: ItemTypeType, fields: FieldMap<ItemTypeType, Fields>, itemIdConversionMap?: ItemIdConversionMap) => void;
 /**
  * @description
  * Returns 'false' if the field changed
  */
-export declare type CompareFieldCallback<ItemTypeType extends ItemType = any> = (field: keyof FieldMap<ItemTypeType>) => boolean;
-export declare type FieldChangeCallbackArgs<ItemTypeType extends ItemType = any> = {
+export declare type CompareFieldCallback<Fields extends ColumnIdTypeMap, T extends keyof Fields = string> = (field: T) => boolean;
+export declare type FieldChangeCallbackArgs<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = {
     itemEntry: ItemEntry<ItemTypeType>;
-    compareField: CompareFieldCallback;
-    fields: FieldMap<ItemTypeType>;
+    compareField: CompareFieldCallback<Fields>;
+    fields: FieldMap<ItemTypeType, Fields>;
     isCalledAfterSocketUpdate: boolean;
-    previous: FieldMap<ItemTypeType>;
+    previous: FieldMap<ItemTypeType, Fields>;
 };
-export declare type FieldChangeCallback<ItemTypeType extends ItemType = any> = (args: FieldChangeCallbackArgs<ItemTypeType>) => void;
+export declare type FieldChangeCallback<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = (args: FieldChangeCallbackArgs<ItemTypeType, Fields>) => void;
 export declare type DeregFunction = () => void;
-export declare type OnChangeCallbackArgs<ItemTypeType extends ItemType = any> = FieldChangeCallbackArgs<ItemTypeType>;
-export declare type OnChangeCallback<ItemTypeType extends ItemType = any> = FieldChangeCallback<ItemTypeType>;
-export declare type OnAddCallbackArgs<ItemTypeType extends ItemType = any> = {
-    itemResources: Array<ItemResource<ItemTypeType>>;
-    collectionResource: CollectionResource<ItemTypeType>;
+export declare type OnChangeCallbackArgs<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = FieldChangeCallbackArgs<ItemTypeType, Fields>;
+export declare type OnChangeCallback<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = FieldChangeCallback<ItemTypeType, Fields>;
+export declare type OnAddCallbackArgs<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = {
+    itemResources: Array<ItemResource<ItemTypeType, Fields>>;
+    collectionResource: CollectionResource<ItemTypeType, Fields>;
     isInitialCall: boolean;
     isCalledAfterSocketUpdate: boolean;
 };
-export declare type OnAddCallback<ItemTypeType extends ItemType = any> = (args: OnAddCallbackArgs<ItemTypeType>) => void;
-export declare type OnRemoveCallbackArgs<ItemTypeType extends ItemType = any> = {
-    itemResources: Array<ItemResource<ItemTypeType>>;
-    collectionResource: CollectionResource<ItemTypeType>;
+export declare type OnAddCallback<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = (args: OnAddCallbackArgs<ItemTypeType, Fields>) => void;
+export declare type OnRemoveCallbackArgs<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = {
+    itemResources: Array<ItemResource<ItemTypeType, Fields>>;
+    collectionResource: CollectionResource<ItemTypeType, Fields>;
     isCalledAfterSocketUpdate: boolean;
 };
-export declare type OnRemoveCallback<ItemTypeType extends ItemType = any> = (args: OnRemoveCallbackArgs<ItemTypeType>) => void;
+export declare type OnRemoveCallback<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = (args: OnRemoveCallbackArgs<ItemTypeType, Fields>) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rentman/rm-core",
-  "version": "6.2.4",
+  "version": "6.3.0",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/types/index.d.ts",