@rentman/rm-core 2.3.0 → 3.0.0

package/dist/{src → types}/classes/ApiFormatter.d.ts

@@ -1,4 +1,4 @@
-import * as moment from 'moment';
+import moment from 'moment';
 import { ColumnInfo } from '../classes';
 import { FieldMap, ItemType } from '../types';
 export declare class ApiFormatter {

package/dist/{src → types}/classes/cache/ItemHandlerBase.d.ts

@@ -50,7 +50,7 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Processes the passed {@link ChangesDeltaItemUpdateDelta update delta} on the transaction, if there are no {@link TransactionItemHandler.itemChanges itemChanges} the new values will not be processed
      */
-    abstract processItemEntryChanges(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta): void;
+    abstract processItemEntryChanges(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): void;
     /**
      * @description
      * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found

package/dist/{src → types}/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, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): FieldMap<ItemTypeType> | null;
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): ServerItemEntryChanges;
     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>>>;

package/dist/{src → types}/classes/cache/transaction/TransactionCache.d.ts

@@ -3,7 +3,7 @@ import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactor
 import { ChangesDeltaFactory } from '../../../factories/ChangesDeltaFactory';
 import { AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { LinkTreeServiceInterface } from '../../../interfaces/LinkTreeServiceInterface';
-import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../../../models';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, ItemEntry, ItemResource } from '../../../models';
 import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
@@ -20,8 +20,8 @@ import { TemplateCache } from '../../TemplateCache';
 import { AbstractCache } from '../AbstractCache';
 import { ServerCache } from '../server/ServerCache';
 import { TransactionEventHandler } from './TransactionEventHandler';
-declare type EditResourceLinks<ItemTypeType extends ItemType> = {
-    main: EditResource<ItemTypeType>;
+declare type ItemResourceLinks<ItemTypeType extends ItemType> = {
+    main: ItemResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
 };
 export declare enum TransactionErrorLevel {
@@ -168,7 +168,7 @@ export declare class TransactionCache extends AbstractCache {
      * @remark
      * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
      */
-    getParent<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     getCollectionChangesRecursively(collectionEntryId: CollectionEntry['id']): ItemEntry[];
     /**
      * @description
@@ -256,123 +256,55 @@ export declare class TransactionCache extends AbstractCache {
     updateItemIdMap(collectionMap: {
         [itemId: number]: any;
     }, conversionMap: ConversionMap): void;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType>, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface & {
-        edit: true;
-    }): PromiseInterface<EditResource<ItemTypeType>>;
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface & {
-        remote: true;
-    }): PromiseInterface<RemoteViewResource<ItemTypeType>>;
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface): PromiseInterface<LocalViewResource<ItemTypeType>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionResource<ItemTypeType>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
+    /**
+     * @description
+     * Clones the {@link CollectionEntry CollectionEntry} and all {@link ItemEntry ItemEntries} in it, and sets the parent of the new entries.
+     * Returns a {@link CollectionResource CollectionResource} of the newly cloned {@link CollectionEntry CollectionEntry}
+     */
+    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType>, conversionMap: ItemIdConversionMap): CollectionResource<ItemTypeType>;
+    /**
+     * @description
+     * Clones the {@link ItemEntry ItemEntry} and returns a {@link ItemResource ItemResource} of the newly cloned {@link ItemEntry ItemEntry}
+     */
+    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface): PromiseInterface<ItemResource<ItemTypeType>>;
+    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    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> & {
-        editCollection: true;
-        editItems: true;
-    }): PromiseInterface<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): PromiseInterface<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-        remoteItems: true;
-    }): PromiseInterface<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): PromiseInterface<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): PromiseInterface<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
+    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
     getCollectionDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
     getLinkCollectionsDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, linkField: string, options: CollectionOptionsInterface<ItemTypeType>): LinkCollectionDefinition<ItemTypeType>;
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface & {
-        edit: true;
-    }): PromiseInterface<Array<EditResource<ItemTypeType>>>;
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface & {
-        remote: true;
-    }): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface & {
-        edit: true;
-    }): PromiseInterface<Array<EditResource<ItemTypeType>>>;
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface & {
-        remote: true;
-    }): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
+    /**
+     * @deprecated
+     * Use getItemById/getNewResourceWithId
+     *
+     * @remarks
+     * stateKey can be a keyword or a local id (in case of a refresh)
+     */
+    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
+     */
+    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options?: ItemOptionsInterface): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches multiple items with their respective changes of the current {@link TransactionCache transaction}
+     */
+    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: ItemOptionsInterface): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the item with the changes of the current {@link TransactionCache transaction}
+     *
+     * @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?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
     /**
      * @description
      * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
@@ -417,45 +349,10 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    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<RemoteViewResource<ItemTypeType>> & {
-        remote: true;
-    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource<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>>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
-        remote: true;
-    }): Array<RemoteViewResource<ItemTypeType>>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface): Array<LocalViewResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface & {
-        edit: true;
-    }): ItemResourcesItemTypeMap<EditResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface & {
-        remote: true;
-    }): ItemResourcesItemTypeMap<RemoteViewResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface): ItemResourcesItemTypeMap<LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface): Array<ItemResource<ItemTypeType>>;
+    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>, options: ItemOptionsInterface): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResource<ItemTypeType>;
     getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
     private createCollectionResources;
     /**

package/dist/{src → types}/classes/index.d.ts

@@ -36,6 +36,7 @@ export * from './cache/transaction/TransactionItemHandler';
 export * from './cache/transaction/TransactionCollectionHandler';
 export * from './cache/transaction/TransactionEventHandler';
 export * from './cache/transaction/TransactionValidator';
+export * from './ChangesDeltaBase';
 export * from './ChangesDelta';
 export * from './InternalChangesDelta';
 export * from './RequestBufferManager';

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

@@ -0,0 +1,16 @@
+import { ItemEntryService, KeyService } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource, CollectionResourceOptionsInterface } from '../models';
+import { ItemType } from '../types';
+import { ChangesDeltaFactory } from './ChangesDeltaFactory';
+export declare class CollectionResourceFactory {
+    errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    changesDeltaFactory: ChangesDeltaFactory;
+    itemEntryService: ItemEntryService;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory, itemEntryService: ItemEntryService);
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, transaction: TransactionCache): CollectionResource<ItemTypeType>;
+}

package/dist/{src → types}/factories/ItemEntryFactory.d.ts

@@ -1,17 +1,15 @@
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
-import { ColumnSetFactory, ItemResourceFactory } from '../factories';
-import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ColumnSetFactory } from '../factories';
+import { ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } from '../models';
 import { ItemId, ItemType } from '../types';
 export declare class ItemEntryFactory {
-    authInterface: AuthInterface;
     apiFormatter: ApiFormatter;
     columnSetFactory: ColumnSetFactory;
     exceptionHandler: ExceptionHandlerInterface;
     itemEntryService: ItemEntryService;
-    itemResourceFactory: ItemResourceFactory;
     keyService: KeyService;
     promiseService: PromiseLibraryInterface;
-    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    constructor(apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface);
     construct<ItemTypeType extends ItemType>(itemId: ItemId, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
 }

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

@@ -0,0 +1,17 @@
+import { ApiFormatter, ColumnUtil } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry, ItemResource } from '../models';
+import { ItemOptionsInterface, ItemType } from '../types';
+export declare type ResourceConstructor<ItemTypeType extends ItemType> = (itemEntry: ItemEntry<ItemTypeType>) => ItemResource<ItemTypeType>;
+export declare class ItemResourceFactory {
+    apiFormatter: ApiFormatter;
+    errorHandler: ErrorHandlerInterface;
+    promiseService: PromiseLibraryInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    columnUtil: ColumnUtil;
+    constructor(apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil);
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, transaction: TransactionCache): ResourceConstructor<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface<ItemTypeType>, transaction: TransactionCache, isNew?: boolean): ItemResource<ItemTypeType>;
+    private constructWithOptions;
+}

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

@@ -0,0 +1,62 @@
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ChangesDeltaResult } from '../classes/ChangesDeltaBase';
+import { CollectionResourceFactory } from '../factories';
+import { CollectionEntry, CollectionResourceOptions, ItemEntry, ItemResource } from '../models';
+import { FieldMap, ItemId, ItemResourceItemIdMap, ItemType, PromiseInterface, QueryCallback, ResponseColumnItemTypeMap } from '../types';
+export declare class CollectionResource<ItemTypeType extends ItemType = any> {
+    protected factory: CollectionResourceFactory;
+    entry: CollectionEntry<ItemTypeType>;
+    options: CollectionResourceOptions<ItemTypeType>;
+    transaction: TransactionCache;
+    items: Array<ItemResource<ItemTypeType>>;
+    columns: ResponseColumnItemTypeMap;
+    protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType>>;
+    private readonly onChange;
+    constructor(factory: CollectionResourceFactory, entry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptions<ItemTypeType>, transaction: TransactionCache);
+    onConstruct(): void;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
+     */
+    moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
+    removeItems(idArray: ItemId[]): void;
+    removeItem(itemId: ItemId): void;
+    addItems(valuesArray: Array<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
+    addItem(values: FieldMap<ItemTypeType>): PromiseInterface<ChangesDeltaResult>;
+    getIdArray(): ItemId[];
+    getItemById(itemId: number): ItemResource<ItemTypeType>;
+    addItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean): Array<ItemResource<ItemTypeType>>;
+    /**
+     * @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>>): Array<ItemResource<ItemTypeType>>;
+    callOnAdd(itemResources: Array<ItemResource<ItemTypeType>>, isInitialCall?: boolean): void;
+    callOnRemove(itemResources: Array<ItemResource<ItemTypeType>>): 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>>;
+    };
+    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType>) => U)): U[];
+    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType>, value: U) => U, value: U): U;
+    /**
+     * @description
+     * Fetches new items and adds them to the collection
+     *
+     * @remarks
+     * - Used to return {@link ItemResource ItemResources}, but you should the {@link CollectionResource.onAdd onAdd) instead
+     */
+    extend(queryCallback: QueryCallback): PromiseInterface<CollectionEntry<ItemTypeType>>;
+    /**
+     * @description
+     * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}
+     *
+     * @remarks
+     * - Doesn't revert changes on the items themselves
+     */
+    clearResource(clearItems?: boolean): void;
+}

package/dist/{src → types}/models/CollectionResourceOptions.d.ts

@@ -6,10 +6,6 @@ export declare type CollectionResourceInitialCallback<ItemTypeType extends ItemT
 export declare type OnItemsCreatedCallback = (conversionMap: ConversionMap) => void;
 export declare type CollectionResourceOptionsInterface<ItemTypeType extends ItemType> = Partial<CollectionResourceOptions<ItemTypeType>>;
 export declare class CollectionResourceOptions<ItemTypeType extends ItemType> {
-    editItems: boolean;
-    remoteItems: boolean;
-    editCollection: boolean;
-    enableSave: boolean;
     callOnAddWithInitialItems: boolean;
     /**
      * @deprecated

package/dist/{src → types}/models/ItemResource.d.ts

@@ -1,20 +1,26 @@
 import { TransactionCache } from '../classes';
 import { ItemResourceFactory } from '../factories';
 import { ItemEntry, ItemResourceOptions } from '../models';
-import { EntryParentNull, FieldMap, ItemType, ResponseColumn } from '../types';
-export declare abstract class ItemResource<ItemTypeType extends ItemType = any> {
+import { EntryParentNull, FieldMap, ItemType, PromiseInterface, ResponseColumn } from '../types';
+export declare class ItemResource<ItemTypeType extends ItemType = any> {
     protected readonly factory: ItemResourceFactory;
     readonly entry: ItemEntry<ItemTypeType>;
-    readonly options: ItemResourceOptions<ItemResource<ItemTypeType>>;
+    readonly options: ItemResourceOptions<ItemTypeType>;
     protected readonly _isNew: boolean;
     protected readonly transaction: TransactionCache;
     columns: {
         [columnId: string]: ResponseColumn;
     };
-    fields: Readonly<FieldMap<ItemTypeType>>;
+    fields: FieldMap<ItemTypeType>;
     initial: Readonly<FieldMap<ItemTypeType>>;
-    protected constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<ItemResource<ItemTypeType>>, _isNew: boolean, transaction: TransactionCache);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, options: ItemResourceOptions<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>;
     /**
      * Fetches the ItemResource's parent with the current fields
      *
@@ -64,7 +70,7 @@ export declare abstract class ItemResource<ItemTypeType extends ItemType = any>
     clearResource(): void;
     toJSON(): {
         columns: string[];
-        fields: Readonly<FieldMap<ItemTypeType>>;
+        fields: FieldMap<ItemTypeType>;
         entry: ItemEntry<ItemTypeType>;
     };
     /**

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

@@ -0,0 +1,6 @@
+import { ItemType, OnChangeFunction } from '../types';
+export declare type ItemResourceOptionsInterface<ItemTypeType extends ItemType = any> = Partial<ItemResourceOptions<ItemTypeType>>;
+export declare class ItemResourceOptions<ItemTypeType extends ItemType = any> {
+    onChange: OnChangeFunction<ItemTypeType>;
+    constructor(values: ItemResourceOptionsInterface<ItemTypeType>);
+}

package/dist/{src → types}/models/index.d.ts

@@ -2,14 +2,8 @@ export * from './ItemEntryOptions';
 export * from './ItemResourceOptions';
 export * from './ItemEntry';
 export * from './ItemResource';
-export * from './ViewResource';
-export * from './EditResource';
 export * from './CollectionEntryOptions';
 export * from './CollectionResourceOptions';
 export * from './CollectionEntry';
 export * from './CollectionResource';
-export * from './CollectionViewResource';
-export * from './CollectionEditResource';
 export * from './Template';
-export * from './RemoteViewResource';
-export * from './LocalViewResource';

package/dist/{src → types}/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<ItemResourceType extends ItemResource<any> = ItemResource> = ItemEntryOptionsInterface & ItemResourceOptionsInterface<ItemResourceType>;
+export declare type ItemOptionsInterface<ItemTypeType extends ItemType = any> = ItemEntryOptionsInterface & ItemResourceOptionsInterface<ItemTypeType>;
 export declare type CollectionOptionsInterface<ItemTypeType extends ItemType = any> = CollectionEntryOptionsInterface & CollectionResourceOptionsInterface<ItemTypeType>;
 export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
     itemType: ItemTypeType;
@@ -24,12 +24,12 @@ export interface CollectionDefinition<ItemTypeType extends ItemType = any> {
 export interface LinkCollectionDefinition<ItemTypeType extends ItemType = any> extends CollectionDefinition<ItemTypeType> {
     linkField: string;
 }
-export declare type OnChangeFunction<ItemResourceType extends ItemResource<any> = ItemResource<any>> = (itemResource: ItemResourceType, previous: FieldMap<ItemResourceType['entry']['itemType']>, 
+export declare type OnChangeFunction<ItemTypeType extends ItemType = any> = (itemResource: ItemResource<ItemTypeType>, previous: FieldMap<ItemTypeType>, 
 /**
  * @description
  * Returns 'false' if the field changed
  */
-compareField: (field: keyof FieldMap<ItemResourceType['entry']['itemType']>) => boolean, isCalledAfterSocketUpdate: boolean) => void;
+compareField: (field: keyof FieldMap<ItemTypeType>) => boolean, isCalledAfterSocketUpdate: boolean) => void;
 export declare const enum StateKeyType {
     New = "new",
     Duplicate = "duplicate"
@@ -157,8 +157,8 @@ export declare type QueryCallback = (queryParams: QueryParams) => QueryParams;
 export declare type CollectionEntryParentIdMap<ItemTypeType extends ItemType> = {
     [parentId: number]: CollectionEntry<ItemTypeType>;
 };
-export declare type CollectionResourceParentIdMap<T extends CollectionResource<any> = CollectionResource<any>> = {
-    [parentId: number]: T;
+export declare type CollectionResourceParentIdMap<ItemTypeType extends ItemType = any> = {
+    [parentId: number]: CollectionResource<ItemTypeType>;
 };
 export declare type CollectionMatchResult<ItemTypeType extends ItemType> = {
     fitting: Array<CollectionEntry<ItemTypeType>>;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@rentman/rm-core",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
-  "types": "./dist/src/index.d.ts",
+  "types": "./dist/types/index.d.ts",
   "dependencies": {},
   "repository": {
     "type": "git",
@@ -13,14 +13,14 @@
     "@types/moment": "^2.13.0",
     "@types/q": "^1.5.0",
     "clean-webpack-plugin": "^0.1.19",
-    "ts-loader": "^4.4.1",
-    "tslint": "^5.12.1",
-    "typescript": "3.3.3",
-    "typescript-tslint-plugin": "^0.5.3",
+    "ts-loader": "^6.2.1",
+    "tslint": "5.19.0",
+    "typescript": "^3.7.2",
+    "typescript-tslint-plugin": "^0.5.5",
     "uglifyjs-webpack-plugin": "^1.2.5",
-    "webpack": "^4.16.3",
-    "webpack-cli": "^3.0.6",
-    "webpack-merge": "^4.1.3"
+    "webpack": "4.41.2",
+    "webpack-cli": "3.3.6",
+    "webpack-merge": "^4.1.4"
   },
   "files": [
     "dist"

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

@@ -1,35 +0,0 @@
-import { ItemEntryService, KeyService } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
-import { ItemType } from '../types';
-import { ChangesDeltaFactory } from './ChangesDeltaFactory';
-export declare class CollectionResourceFactory {
-    errorHandler: ErrorHandlerInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    itemResourceFactory: ItemResourceFactory;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    changesDeltaFactory: ChangesDeltaFactory;
-    itemEntryService: ItemEntryService;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory, itemEntryService: ItemEntryService);
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, transaction: TransactionCache): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-}