@rentman/rm-core 2.0.2 → 2.0.4

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

@@ -33,6 +33,10 @@ export declare class ApiFormatter {
     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;
+    /**
+     * @description
+     * Compares the given fields, returns `true` when the fields are equal
+     */
     compareFields(columnType: string, first?: any, second?: any): boolean;
     compareFloats(a: number, b: number): boolean;
     compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;

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

@@ -1,4 +1,4 @@
-import { ApiFormatter } from '../classes';
+import { ApiFormatter, ApiRequestService } from '../classes';
 import { RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
@@ -15,7 +15,8 @@ export declare class SocketMessageHandler {
     private transactionCacheFactory;
     private promiseService;
     private requestColumnExpansionFactory;
-    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    private apiRequestService;
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
     onMessageReceived(message: SocketMessage): any;
     private formatMessageValues;
     private createCollectionMap;

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

@@ -19,7 +19,7 @@ export declare class TemplateCache {
     constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, requestBufferFactory: RequestBufferManager, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
     /**
      * @description
-     * Fetches a {@link Template template}
+     * Fetches a {@link Template template}, {@link TransactionItemHandler.createItems TransactionItemHandler.createItems} is a convenience function for this
      *
      * @param itemType The {@link ItemType ItemType} of the template item
      * @param itemId Used for caching, multiple concurrent template calls for the same itemId will return the same template

package/dist/src/classes/cache/AbstractCache.d.ts

@@ -10,11 +10,13 @@ import { ApiRequestService } from '../ApiRequestService';
 import { ChangesDelta } from '../ChangesDelta';
 import { ChangesDeltaResult } from '../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../ChangesProcessor';
+import { CollectionCache } from '../CollectionCache';
 import { CollectionEntryService } from '../CollectionEntryService';
 import { ColumnCache } from '../ColumnCache';
 import { ColumnHandler } from '../ColumnHandler';
 import { ColumnUtil } from '../ColumnUtil';
 import { InternalChangesDelta } from '../InternalChangesDelta';
+import { ItemCache } from '../ItemCache';
 import { ItemEntryService } from '../ItemEntryService';
 import { KeyService } from '../KeyService';
 import { LockService } from '../LockService';
@@ -68,6 +70,16 @@ export declare abstract class AbstractCache {
     protected constructor(core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, apiFormatter: ApiFormatter, linkTreeService: LinkTreeServiceInterface);
     createChild(id?: string): TransactionCache;
     onChildDestroy(cache: TransactionCache): void;
+    /**
+     * @description
+     * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction
+     */
+    getCurrentCollectionEntryCache(): CollectionCache;
+    /**
+     * @description
+     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
+     */
+    getCurrentItemEntryCache(): ItemCache;
     abstract getServerCache(): ServerCache;
     abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     abstract getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
@@ -88,7 +100,7 @@ export declare abstract class AbstractCache {
      *
      * @internal
      */
-    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean): void;
+    abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
     abstract getParent(itemEntry: ItemEntry, fromInitial?: boolean): EntryParentNull;
     abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;

package/dist/src/classes/cache/CollectionHandlerBase.d.ts

@@ -51,10 +51,10 @@ export declare abstract class CollectionHandlerBase {
      * Adds the passed {@link ItemEntry ItemEntries} to the collection's changes on the transaction,
      * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
      */
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
-    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
-    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[]): void | never[];
-    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    protected _addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean, isCalledAfterSocketUpdate: boolean): void;
+    protected abstract handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
+    removeItemEntriesFromCollectionChanges(collectionEntry: CollectionEntry, idArray: ItemId[], isCalledAfterSocketUpdate?: boolean): void | never[];
+    protected abstract handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate: boolean): void;
     /**
      * @description
      * Expands the option's {@link CollectionEntryOptions.columns columns} with the columns required for the {@link CollectionMatcher CollectionMatcher} to function.

package/dist/src/classes/cache/CollectionMatcherCacheProcessor.d.ts

@@ -21,6 +21,6 @@ export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType
 export declare class CollectionMatcherCacheProcessor extends CollectionMatcher {
     private apiRequestService;
     constructor(apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollectionEntries: (itemType: ItemType) => CollectionEntry[]);
-    removeFromAndAddToCollections(): void;
+    removeFromAndAddToCollections(isCalledAfterSocketUpdate?: boolean): void;
     private groupItemEntries;
 }

package/dist/src/classes/cache/server/ServerCache.d.ts

@@ -41,12 +41,12 @@ export declare class ServerCache extends AbstractCache {
     parent: null;
     constructor(changesProcessorFactory: ChangesProcessorFactory, core: RmCore, columnCache: ColumnCache, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, queryMatcherFactory: QueryMatcherFactory, authInterface: AuthInterface, changesDeltaFactory: ChangesDeltaFactory, lockService: LockService, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceFactory: ItemResourceFactory, templateCache: TemplateCache, itemCacheFactory: ItemCacheFactory, collectionCacheFactory: CollectionCacheFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface, apiFormatter: ApiFormatter, apiRequestService: ApiRequestService, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, queryParserFactory: QueryParserFactory, queryService: QueryService, linkTreeService: LinkTreeServiceInterface);
     getServerCache(): ServerCache;
-    processResponse(response: ApiResponseProcessor): PromiseInterface<ChangesDeltaResult>;
+    processResponse(response: ApiResponseProcessor, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
     /**
      * @description
      * Applies the changes of the changesDelta created by the API call ({@link ChangesProcessor ChangesProcessor}/{@link SocketMessageHandler SocketMessageHandler}, or manually through a module function) on all caches
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean): void;
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): void;
     /**
      * @description
      * Gets the fields required to set the parent
@@ -79,7 +79,7 @@ export declare class ServerCache extends AbstractCache {
      * Applies changes to this transaction and its children
      * Differs from {@link TransactionCache.applyChangesDelta TransactionCache.applyChangesDelta} in the handling of deleted entries and the applyChangesFromParent call
      */
-    applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
     getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
     getLocalCollectionEntry(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;

package/dist/src/classes/cache/server/ServerCollectionHandler.d.ts

@@ -26,7 +26,7 @@ export declare class ServerCollectionHandler extends CollectionHandlerBase {
     extendCollectionEntry<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, queryCallback: QueryCallback): PromiseInterface<CollectionEntryType>;
     expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
     protected handleAddedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, addedEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
     protected handleRemovedItemEntriesCallback<CollectionEntryType extends CollectionEntry>(_collectionEntry: CollectionEntryType, removedItemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
     /**

package/dist/src/classes/cache/server/ServerItemHandler.d.ts

@@ -23,7 +23,7 @@ export declare class ServerItemHandler extends ItemHandlerBase {
      * @description
      * Processes updates on a cached entry
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
     fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;

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

@@ -10,7 +10,7 @@ import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { CollectionEntryService } from '../../CollectionEntryService';
 import { ColumnHandler } from '../../ColumnHandler';
 import { ColumnUtil } from '../../ColumnUtil';
-import { ApiFormatter, ApiRequestService, CollectionCache, ColumnCache, ItemCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler } from '../../index';
+import { ApiFormatter, ApiRequestService, ColumnCache, LockService, ModuleChangesCompilationResult, OnAfterCreateCallback, RequestBufferManager, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler } from '../../index';
 import { InternalChangesDelta } from '../../InternalChangesDelta';
 import { ItemEntryService } from '../../ItemEntryService';
 import { KeyService } from '../../KeyService';
@@ -92,7 +92,7 @@ export declare class TransactionCache extends AbstractCache {
      * @param internalChangesDelta Changes to be applied
      * @param isCalledAfterApiSave If 'isCalledAfterApiSave' is true local changes will always be overwritten (instead of only when there are no changes)
      */
-    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean): void;
+    applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): void;
     /**
      * @description
      * Applies changes to this transaction and its children
@@ -202,16 +202,6 @@ export declare class TransactionCache extends AbstractCache {
     updateItemIdMap(collectionMap: {
         [itemId: number]: any;
     }, conversionMap: ConversionMap): void;
-    /**
-     * @description
-     * Returns the {@link TransactionCollectionHandler.entries CollectionCache} of the transaction
-     */
-    getCurrentCollectionEntryCache(): CollectionCache;
-    /**
-     * @description
-     * Returns the {@link TransactionItemHandler.entries ItemCache} of the transaction
-     */
-    getCurrentItemEntryCache(): ItemCache;
     cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
         editItems: true;
         editCollection: true;
@@ -368,13 +358,13 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<EditResource<ItemTypeType>> & {
         edit: true;
     }, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<RemoteViewResource<ItemTypeType>> & {
         remote: true;
     }, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<LocalViewResource<ItemTypeType>>, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
     createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
         edit: true;
     }): Array<EditResource<ItemTypeType>>;

package/dist/src/classes/cache/transaction/TransactionCollectionHandler.d.ts

@@ -49,7 +49,7 @@ export declare class TransactionCollectionHandler extends CollectionHandlerBase
     fetchLinkedCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
     expandCollectionEntries<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     extendCollectionEntries<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T): PromiseInterface<void>;
-    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>): void;
+    addItemEntriesToCollectionChanges<CollectionEntryType extends CollectionEntry>(collectionEntry: CollectionEntryType, itemEntries: Array<ItemEntry<CollectionEntryType['itemType']>>, isCalledAfterSocketUpdate?: boolean): void;
     isLocal(options: CollectionEntryOptions): boolean;
     expandCollectionEntry<CollectionEntryType extends CollectionEntry>(changesDelta: ChangesDelta, collectionEntry: CollectionEntryType, newColumns: ApiRequestColumns): PromiseInterface<CollectionEntryType>;
     /**

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

@@ -76,11 +76,12 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @param itemEntryChangesTuple The changes tuple
      * @param forceOverwrite Instead of calling {@link ApiFormatter.mergeCopyFields mergeCopyFields}, {@link ApiFormatter.copyFields copyFields} will be used (because API values are always right)
      * @param updateInitial Should be `true` if called by applyChangesFromParent
+     * @param isCalledAfterSocketUpdate Indicates that the change is done by a different user
      *
      * @returns
      * The previous changes {@link FieldMap FieldMap}
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean): FieldMap<ItemTypeType>;
     cloneItemEntries<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): PromiseInterface<ChangesDeltaResult>;
     cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, newFields?: FieldMap<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: (sourceEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>) => void): ItemId;
     fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;

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

@@ -10,28 +10,8 @@ export declare class CollectionEditResource<ItemTypeType extends ItemType = any,
      * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
      */
     moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemDeleted ChangesDelta.setItemDeleted}
-     */
     removeItems(idArray: ItemId[]): void;
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemDeleted ChangesDelta.setItemDeleted}
-     */
     removeItem(itemId: ItemId): void;
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemCreated ChangesDelta.setItemCreated}
-     *
-     * todo[cache] this will fetchCollectionEntry a template for you, make a convenience function ?
-     */
     addItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemCreated ChangesDelta.setItemCreated}
-     *
-     * todo[cache] this will fetchCollectionEntry a template for you, make a convenience function ?
-     */
     addItem(values: FieldMap<ItemTypeType>): PromiseInterface<ChangesDeltaResult>;
 }

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

@@ -12,7 +12,7 @@ export declare type EntryParentNull = EntryParent | null;
 export declare type FieldMap<_ItemTypeType extends ItemType = any> = {
     [key: string]: any;
 };
-export declare type ItemOptionsInterface = ItemEntryOptionsInterface & ItemResourceOptionsInterface;
+export declare type ItemOptionsInterface<ItemResourceType extends ItemResource<any> = ItemResource> = ItemEntryOptionsInterface & ItemResourceOptionsInterface<ItemResourceType>;
 export declare type CollectionOptionsInterface<ItemTypeType extends ItemType = any> = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface<ItemTypeType>;
 export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
@@ -27,9 +27,9 @@ export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> e
 export declare type OnChangeFunction<ItemResourceType extends ItemResource<any> = ItemResource<any>> = (itemResource: ItemResourceType, previous: FieldMap<ItemResourceType['entry']['itemType']>, 
 /**
  * @description
- * Returns 'true' if the field changed
+ * Returns 'false' if the field changed
  */
-compareField: (field: keyof FieldMap<ItemResourceType['entry']['itemType']>) => boolean) => void;
+compareField: (field: keyof FieldMap<ItemResourceType['entry']['itemType']>) => boolean, isCalledAfterSocketUpdate: boolean) => void;
 export declare const enum StateKeyType {
     New = "new",
     Duplicate = "duplicate"

package/package.json

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