@rentman/rm-core 7.1.1 → 8.0.0

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { RmCore } from '../../core';
 import { AbstractCacheDependencyInterface } from '../../interfaces';
 import { ItemEntry } from '../../models';
-import { ApiRequestColumn, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../types';
+import { ApiRequestColumn, CollectionQuery, CollectionResourceParentIdMap, EntryParentNull, FieldMap, ItemIdConversionMap, PromiseInterface } from '../../types';
 import { ChangesDelta } from '../ChangesDelta';
 import { ChangesDeltaResult } from '../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../ChangesProcessor';
@@ -32,12 +33,12 @@ export declare abstract class AbstractCache {
      *
      * todo[limit] move to TransactionCache ?
      */
-    abstract expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    abstract expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     /**
      * @description
      * Returns {@link ItemEntry ItemEntries} that fit the collection's query, copies over the collectionChanges on all transactions in the chain.
      */
-    abstract getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    abstract getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
     /**
      * @description
      * Returns this transaction and all parents
@@ -50,7 +51,7 @@ export declare abstract class AbstractCache {
     getCurrentItemEntryCache(): ItemCache;
     abstract getServerCache(): ServerCache;
     abstract getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    abstract getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    abstract getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
     /**
      * @description
      * Applies changes from a child transaction to a parent
@@ -68,7 +69,7 @@ export declare abstract class AbstractCache {
      * @internal
      */
     abstract applyChangesFromParent(internalChangesDelta: InternalChangesDelta, isCalledAfterApiSave: boolean, isCalledAfterSocketUpdate: boolean): void;
-    abstract getParent<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    abstract getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     abstract getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     abstract getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): any;
     /**
@@ -80,9 +81,9 @@ export declare abstract class AbstractCache {
      *
      * @internal
      */
-    abstract getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+    abstract getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType> | TransactionItemEntryChanges<FieldMap<ItemTypeType>>): FieldMap<ItemTypeType>;
     abstract applyChangesDelta(changesDelta: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
-    protected getParentFromFields<ItemTypeType extends ItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParentNull;
+    protected getParentFromFields<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParentNull;
     /**
      * @description
      * Called by applyChangesDelta from ServerCache and TransactionCache. Applies creates, updates and moves, doesn't apply deletes
@@ -93,7 +94,6 @@ export declare abstract class AbstractCache {
         result: ChangesDeltaResult;
         internalChangesDelta: InternalChangesDelta;
         matchingDelta: InternalChangesDelta;
-        rollbackFunctions: Array<(changesDelta: ChangesDelta) => void>;
     };
     /**
      * @description

package/dist/types/classes/cache/CachedQueryHandlerBase.d.ts

@@ -1,13 +1,14 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { RequestColumnExpansionFactory } from '../../factories';
 import { PromiseLibraryInterface } from '../../interfaces';
 import { ItemEntry } from '../../models';
 import { CollectionOptions } from '../../models/CollectionOptions';
-import { ApiQuery, ApiRequestColumns, CollectionQuery, ItemId, ItemType, ParentIdMap, PromiseInterface } from '../../types';
+import { ApiQuery, ApiRequestColumns, CollectionQuery, ParentIdMap, PromiseInterface } from '../../types';
 import { CollectionEntryService } from '../CollectionEntryService';
 import { ColumnSubsetCache } from '../ColumnSubsetCache';
 import { ColumnUtil } from '../ColumnUtil';
 import { AbstractCache } from './AbstractCache';
-export declare type CachedQueryItem<ItemTypeType extends ItemType = any> = {
+export declare type CachedQueryItem<ItemTypeType extends ApiEnumItemType = any> = {
     itemType: ItemTypeType;
     query: CollectionQuery;
     items: Array<ItemEntry<ItemTypeType>>;
@@ -35,40 +36,40 @@ export declare abstract class CachedQueryHandlerBase {
         };
     };
     protected constructor(collectionEntryService: CollectionEntryService, columnUtil: ColumnUtil, requestColumnExpansionFactory: RequestColumnExpansionFactory, promiseService: PromiseLibraryInterface, transaction: AbstractCache);
-    setCachedQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
-    getCachedQueryItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, queryString: string): undefined | Array<ItemEntry<ItemTypeType>>;
-    getCachedQueryObjectsByItemType(itemType: ItemType): CachedQueryItem[];
-    initCachedQuery<ItemTypeType extends ItemType = string>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
+    setCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
+    getCachedQueryItems<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, queryString: string): undefined | Array<ItemEntry<ItemTypeType>>;
+    getCachedQueryObjectsByItemType(itemType: ApiEnumItemType): CachedQueryItem[];
+    initCachedQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, requestColumns: ApiRequestColumns): CachedQueryItem<ItemTypeType>;
     /**
      * @description
      * Fetches a {@link CollectionEntry CollectionEntry} with the given options
      */
-    abstract __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    abstract __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     /**
      * @description
      * Fetches collections linked to the passed parents
      */
-    abstract __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    abstract __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     /**
      * @description
      * Fetches collections linked to the passed parents
      */
-    abstract __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    abstract __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
     /**
      * @description
      * Adds the passed {@link ItemEntry ItemEntries} to the Transaction's query cache,
      * will skip the ItemEntry if the `skipEntryFilterFn` callback returns `true`
      */
-    protected __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
+    protected __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>, skipEntryFilterFn: (temEntry: ItemEntry) => boolean): void;
     /**
      * @description
      * Removes the passed {@link ItemId ItemIds} from the Transaction's query cache
      */
-    __removeItemEntriesFromCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemEntry<ItemTypeType>>;
+    __removeItemEntriesFromCachedQueries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Expands the option's {@link CollectionOptions.columns columns} with the columns required for the {@link CollectionMatcherCachedCollectionProcessor CollectionMatcher} to function.
      * Data fetched for a parent transaction might also fit in a child transaction, so those {@link CollectionOptions.queryColumns queryColumns} should also be taken into account
      */
-    expandColumnsWithQueryColumns(itemType: ItemType, options: CollectionOptions, query: ApiQuery): void;
+    expandColumnsWithQueryColumns(itemType: ApiEnumItemType, options: CollectionOptions, query: ApiQuery): void;
 }

package/dist/types/classes/cache/CollectionMatcherCachedQueryProcessor.d.ts

@@ -1,14 +1,15 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { QueryMatcherFactory } from '../../factories';
 import { PromiseLibraryInterface } from '../../interfaces';
 import { ItemEntry } from '../../models';
-import { CollectionQuery, ItemType, PromiseInterface } from '../../types';
+import { CollectionQuery, PromiseInterface } from '../../types';
 import { ApiRequestService } from '../ApiRequestService';
 import { ChangesDeltaBase } from '../ChangesDeltaBase';
 import { CollectionMatcherBase, CollectionMatcherMatches } from '../CollectionMatcherBase';
 import { QueryService } from '../QueryService';
 import { AbstractCache } from './AbstractCache';
 import { CachedQueryItem } from './CachedQueryHandlerBase';
-export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
+export declare type GroupedCollectionMatcherResult<ItemTypeType extends ApiEnumItemType> = {
     fitting: Array<ItemEntry<ItemTypeType>>;
     notFitting: Array<ItemEntry<ItemTypeType>>;
     maybe: Array<ItemEntry<ItemTypeType>>;
@@ -23,13 +24,13 @@ export declare class CollectionMatcherCachedQueryProcessor extends CollectionMat
     private getQueries;
     protected map: {
         [itemTypeAndQueryString: string]: {
-            itemType: ItemType;
+            itemType: ApiEnumItemType;
             query: CollectionQuery;
             matches: CollectionMatcherMatches;
             cachedQuery: CachedQueryItem;
         };
     };
-    constructor(apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getQueries: (itemType: ItemType) => CachedQueryItem[]);
+    constructor(apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getQueries: <ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType) => Array<CachedQueryItem<ItemTypeType>>);
     __removeFromAndAddToCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
-    protected _expand<ItemTypeType extends ItemType = string>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+    protected _expand<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
 }

package/dist/types/classes/cache/ItemHandlerBase.d.ts

@@ -1,7 +1,8 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../types';
+import { ApiQuery, ApiRequestColumns, FieldMap, PromiseInterface } from '../../types';
 import { ApiFormatter } from '../ApiFormatter';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta } from '../ChangesDeltaBase';
 import { ColumnInfo } from '../ColumnInfo';
@@ -16,7 +17,7 @@ export declare enum ItemCacheStatus {
     NOT_CACHED = "not_cached",
     NO_CHANGES = "no_changes"
 }
-export declare type ProcessItemEntryChangesResult<ItemTypeType extends ItemType> = {
+export declare type ProcessItemEntryChangesResult<ItemTypeType extends ApiEnumItemType> = {
     status: ItemCacheStatus.NO_CHANGES | ItemCacheStatus.NOT_CACHED;
     previous: null;
 } | {
@@ -32,7 +33,9 @@ export declare abstract class ItemHandlerBase {
     protected requestColumnExpansionFactory: RequestColumnExpansionFactory;
     protected transaction: AbstractCache;
     readonly entries: ItemCache;
-    abstract itemChanges: ServerItemEntryChanges | TransactionItemEntryChanges;
+    abstract itemChanges: {
+        [itemEntryId: string]: ServerItemEntryChanges | TransactionItemEntryChanges;
+    };
     protected constructor(columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, promiseService: PromiseLibraryInterface, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemCacheFactory: ItemCacheFactory, transaction: AbstractCache);
     /**
      * @description
@@ -45,22 +48,22 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Fetches the ItemEntries for the given query, does not look in the cache, since we don't know which ItemIds belong to the query !
      */
-    abstract fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    abstract fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
      * Fetches the ItemEntries for the given ItemIds
      */
-    abstract fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    abstract fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
      * Fetches an ItemEntry with the given itemId
      */
-    abstract fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    abstract fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
      * @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<ItemTypeType extends ItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    abstract processItemEntryChanges<ItemTypeType extends ApiEnumItemType>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite: boolean, updateInitial: boolean, isCalledAfterSocketUpdate: boolean, createItemChangesIfNoneExist: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
     /**
      * @description
      * Traverses the column path and returns the fields of the derived item, returns undefined if the item isn't found
@@ -89,8 +92,8 @@ export declare abstract class ItemHandlerBase {
      * Recursively fetches derived values as separate requests, instead of as columns of a primary item
      * Can be used when derived values of a local item have to be fetched, since a local item can't be used as root item of a query
      */
-    fetchDerivedValuesByColumn<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, changesDelta?: ChangesDeltaBase): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchDerivedValuesByColumn<ItemTypeType extends ApiEnumItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, rootColumn: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): PromiseInterface<void | Array<ItemEntry<ItemTypeType>>>;
+    resolveDerivedValues<ItemTypeType extends ApiEnumItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, changesDelta?: ChangesDeltaBase): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
      * Creates a new {@link ItemEntry ItemEntry} from the passed {@link ChangesDeltaItemCreateDelta ChangesDeltaItemCreateDelta} and stores it in this transaction's {@link ItemCache ItemCache}
@@ -100,6 +103,6 @@ export declare abstract class ItemHandlerBase {
      * @description
      * Gets the value of the given column, will look into the current delta before attempting to read itemChanges
      */
-    protected getItemIdByColumn<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
-    expandColumnsWithCachedQueryColumns(itemType: ItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
+    protected getItemIdByColumn<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, column: ColumnInfo<ItemTypeType>, changesDelta?: ChangesDeltaBase): ItemId;
+    expandColumnsWithCachedQueryColumns(itemType: ApiEnumItemType, requestColumns?: ApiRequestColumns): ApiRequestColumns;
 }

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

@@ -1,8 +1,9 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ChangesDelta, InternalChangesDelta, TransactionCache, TransactionValidatorFactory } from '../..';
 import { RmCore } from '../../../core';
 import { ServerCacheDependencyInterface } from '../../../interfaces/ServerCacheDependencyInterface';
 import { ItemEntry } from '../../../models';
-import { ApiRequestColumn, ApiRequestColumnMap, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, ItemType, PromiseInterface } from '../../../types';
+import { ApiRequestColumn, ApiRequestColumnMap, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, PromiseInterface } from '../../../types';
 import { ApiResponseProcessor } from '../../ApiResponseProcessor';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
@@ -25,7 +26,7 @@ export declare class ServerCache extends AbstractCache {
     constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
     getServerCache(): ServerCache;
     createChild(id?: string, validatorFactory?: TransactionValidatorFactory): TransactionCache;
-    expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
     processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta): PromiseInterface<ChangesDeltaResult>;
     /**
      * @description
@@ -36,7 +37,7 @@ export declare class ServerCache extends AbstractCache {
      * @description
      * Gets the fields required to set the parent
      */
-    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    getLinkFieldsByParent<ItemTypeType extends ApiEnumItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
     /**
      * @description
      * Gets the entry's parent
@@ -48,7 +49,7 @@ export declare class ServerCache 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 = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
     getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
     /**
      * @description
@@ -58,7 +59,7 @@ export declare class ServerCache extends AbstractCache {
         entry: ItemEntry;
         changes: ServerItemEntryChanges;
     };
-    getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
     /**
      * @description
      * Invalidates the complete server cache, all items will be re-fetched whenever they are requested
@@ -77,6 +78,6 @@ export declare class ServerCache extends AbstractCache {
      */
     applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterApiSave?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<ChangesDeltaResult>;
     getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    getChangesFromItemChanges<ItemTypeType extends ItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+    getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
 }

package/dist/types/classes/cache/server/ServerCachedQueryHandler.d.ts

@@ -1,9 +1,9 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
 import { ApiRequestColumns, ApiRequestService, CollectionQuery, ColumnSubsetCache, ColumnUtil, ParentIdMap, PromiseInterface } from '../../../index';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { ItemEntry } from '../../../models';
 import { CollectionOptions } from '../../../models/CollectionOptions';
-import { ItemId, ItemType } from '../../../types';
 import { CollectionEntryService } from '../../index';
 import { RequestBufferManager } from '../../RequestBufferManager';
 import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
@@ -17,18 +17,18 @@ export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
     private itemHandler;
     protected transaction: ServerCache;
     constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, transaction: ServerCache);
-    __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
     /**
      * @description
      * Expands the columns of the items in the cached query
      */
-    __expandCachedQuery<ItemTypeType extends ItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
     /**
      * @description
      * Fetches the data for the passed ItemType/options, will do nothing if the requested CollectionEntry/columns are already cached.
      * Will create a new {@link CollectionEntry CollectionEntry} if the CollectionEntry didn't exist yet
      */
-    __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
 }

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

@@ -1,14 +1,15 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, ItemId, ItemType, PromiseInterface } from '../../../types';
+import { ApiQuery, ApiRequestColumns, FieldMap, PromiseInterface } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaItemUpdateDelta } from '../../ChangesDeltaBase';
 import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
 import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse, TransactionItemEntryChanges } from '../../index';
 import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
 import { ServerCache } from './ServerCache';
-export declare type ServerItemEntryChanges<ItemTypeType extends ItemType = any> = FieldMap<ItemTypeType>;
+export declare type ServerItemEntryChanges<ItemTypeType extends ApiEnumItemType = any> = FieldMap<ItemTypeType>;
 export declare class ServerItemHandler extends ItemHandlerBase {
     private requestBufferManager;
     private queryParserFactory;
@@ -24,25 +25,25 @@ 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): ProcessItemEntryChangesResult<ItemTypeType>;
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _forceOverwrite?: boolean, _updateInitial?: boolean, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
     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>>>;
-    extendItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, newColumns: ApiRequestColumns): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    extendItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, newColumns: ApiRequestColumns): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
      * Fetches the data for the ItemEntries linked to the parent Items
      *
      * @param columns should contain a derived column that refers to the parent
      */
-    fetchLinkedItemEntriesData(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery | null, columns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchLinkedItemEntriesData(parentType: ApiEnumItemType, parentIdArray: ItemId[], itemType: ApiEnumItemType, query: ApiQuery | null, columns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     /**
      * @description
      * General way to process an API response.
      * Will call {@link ChangesDelta.setItemCreated setItemCreated} if an entry doesn't exist yet, and otherwise {@link ChangesDelta.setItemUpdated setItemUpdated} if it does.
      */
-    processApiResponse<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemIdOfExistingItem: ItemId, itemIdInResponse: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>): void;
+    processApiResponse<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemIdOfExistingItem: ItemId, itemIdInResponse: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>): void;
     /**
      * @description
      * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.

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

@@ -1,9 +1,10 @@
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
 import { ChangesDelta, InternalChangesDelta, ServerCache, TransactionCollectionHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionValidatorFactory } from '../..';
 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, ColumnIdTypeMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
+import { ApiQuery, ApiRequestColumn, ApiRequestColumns, CollectionDefinition, CollectionQuery, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemTypeMap, LinkCollectionDefinition, PromiseInterface } from '../../../types';
 import { ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { OnAfterCreateCallback } from '../../ChangesProcessor';
 import { ModuleChangesCompilationResult } from '../../ModuleChangesCompilation';
@@ -11,7 +12,7 @@ import { AbstractCache } from '../AbstractCache';
 import { CachedQueryItem } from '../CachedQueryHandlerBase';
 import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
 import { TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionEventHandler } from './TransactionEventHandler';
-declare type ItemResourceLinks<ItemTypeType extends ItemType> = {
+declare type ItemResourceLinks<ItemTypeType extends ApiEnumItemType> = {
     main: ItemResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
 };
@@ -104,8 +105,8 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Expands the collection with the new request columns, assumes that all collections have the same itemType
      */
-    expandCollectionResources<ItemTypeType extends ItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     createChangesDelta(): ChangesDelta;
     getFirstErrorString(): undefined | string;
     /**
@@ -168,8 +169,8 @@ 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 = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    getCollectionChangesRecursively<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, fromInitial?: boolean, providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
     /**
      * @description
      * Traverses the transaction chain and returns the changes of the item on the first transaction
@@ -236,13 +237,13 @@ export declare class TransactionCache extends AbstractCache {
     updateItemIdMap(collectionMap: {
         [itemId: number]: any;
     }, conversionMap: ConversionMap): void;
-    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, 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>;
+    getAllLinkCollections<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getLinkCollectionsFromDef<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getLinkCollections<ItemTypeType extends ApiEnumItemType>(linkType: ApiEnumItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<ItemTypeType>>;
+    getCollectionFromDef<ItemTypeType extends ApiEnumItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
+    getCollection<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType, ColumnIds>>;
+    getCollectionDef<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
+    getLinkCollectionsDef<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, linkField: string, options: CollectionOptionsInterface<ItemTypeType>): LinkCollectionDefinition<ItemTypeType>;
     /**
      * @deprecated
      * Use getItemById/getNewResourceWithId
@@ -250,35 +251,35 @@ export declare class TransactionCache extends AbstractCache {
      * @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: Partial<ItemEntryOptions>, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, 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>>;
+    getItemByState<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options?: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getDuplicateById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResourceWithId<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: Partial<ItemEntryOptions>, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<ItemResourceLinks<ItemTypeType>>;
+    getNewResource<ItemTypeType extends ApiEnumItemType>(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?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    getItemsByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, options?: Partial<ItemEntryOptions>): 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?: Partial<ItemEntryOptions>): PromiseInterface<Array<ItemResource<ItemTypeType>>>;
+    getItemsById<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options?: Partial<ItemEntryOptions>): 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, Fields extends FieldMap<ItemTypeType> = FieldMap<ItemTypeType>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, Fields>>;
+    getItemById<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, itemId: ItemId, options?: Partial<ItemEntryOptions>, isRoot?: boolean): PromiseInterface<ItemResource<ItemTypeType, ColumnIds>>;
     /**
      * @description
      * Fetches the title of an item, does not create an {@link ItemResource ItemResource}
      */
-    fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
+    fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
     /**
      * @description
      * Merges the passed child Transaction into this transaction and then propagates them to the other child transactions
@@ -301,18 +302,18 @@ export declare class TransactionCache extends AbstractCache {
      * @description
      * Gets an ItemEntry from the cache by ItemId
      */
-    getLocalItemEntryByItemId(itemType: ItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
     /**
      * @description
      * Returns the complete {@link InternalChangesDelta InternalChangesDelta} of the TransactionCache, this only takes into account the end result (initial is compared to changes), so changing something and reverting it
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): 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>;
+    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, isRoot?: boolean, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>): Array<ItemResource<ItemTypeType, ColumnIds>>;
+    processLinkedItems<ItemTypeType extends ApiEnumItemType>(linkedEntries: ItemTypeMap<ItemEntry[]>): ItemResourcesItemTypeMap<ItemResource<ItemTypeType>>;
+    createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
+    getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: TransactionItemEntryChanges<FieldMap<ItemTypeType>>): FieldMap<ItemTypeType>;
     /**
      * @description
      * Fetches all required columns to match/fit in collections

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

@@ -1,7 +1,7 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ApiQuery, ApiRequestColumns, CollectionQuery, ColumnSubsetCache, ItemEntryOptions, ParentIdMap, PromiseInterface, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../index';
 import { ItemEntry } from '../../../models';
 import { CollectionOptions } from '../../../models/CollectionOptions';
-import { ItemId, ItemType } from '../../../types';
 import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
 import { TransactionCache } from './TransactionCache';
 export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
@@ -9,15 +9,15 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
     private itemHandler;
     protected transaction: TransactionCache;
     constructor(dependencies: TransactionCollectionHandlerDependencyInterface, itemHandler: TransactionItemHandler, transaction: TransactionCache);
-    __fetchCachedQueryItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __expandCachedQuery<ItemTypeType extends ItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
     /**
      * @remark
      * todo not only linkedTo should be checked, but it should check if there's a local ID anywhere in the query
      * ({<field>: <localId>}) is also a local query
      */
     isLocal(options: CollectionOptions | ItemEntryOptions, query: ApiQuery): boolean;
-    __fetchItemEntriesByQueryData<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
 }

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

@@ -1,6 +1,7 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { TransactionCollectionHandlerDependencyInterface } from '../../../interfaces/TransactionCollectionHandlerDependencyInterface';
 import { CollectionEntry, CollectionResource, ItemEntry } from '../../../models';
-import { ApiRequestColumns, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../../../types';
+import { ApiRequestColumns, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { TransactionCache } from './TransactionCache';
 import { TransactionCachedQueryHandler } from './TransactionCachedQueryHandler';
@@ -16,7 +17,7 @@ export declare class TransactionCollectionHandler {
         };
     };
     constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
-    expandCollectionResource<ItemTypeType extends ItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
+    expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
     addResource(resource: CollectionResource): void;
     clearResource(resource: CollectionResource): void;
     /**