@rentman/rm-core 7.1.1 → 8.0.0

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

@@ -1,15 +1,16 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { TransactionItemHandlerDependencyInterface } from '../../../interfaces';
 import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, ColumnIdTypeMap, DeregFunction, FieldChangeCallback, FieldMap, ItemId, ItemIdConversionMap, ItemType, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
+import { ApiQuery, ApiRequestColumns, DeregFunction, FieldChangeCallback, FieldMap, ItemIdConversionMap, ItemTypeMap, ModifyFieldsCallback, PromiseInterface, ResponseColumnItemTypeMap } from '../../../types';
 import { ChangesDelta } from '../../ChangesDelta';
 import { ChangesDeltaBase, ChangesDeltaItemUpdateDelta, ChangesDeltaResult } from '../../ChangesDeltaBase';
 import { ChangesDeltaItemCreateDelta, ColumnSubsetCache } from '../../index';
 import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
 import { TransactionCache } from './TransactionCache';
 import { TransactionValidator } from './TransactionValidator';
-export declare type TransactionItemEntryChanges<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> = {
-    initial: FieldMap<ItemTypeType, Fields>;
-    changes: FieldMap<ItemTypeType, Fields>;
+export declare type TransactionItemEntryChanges<Fields extends FieldMap = FieldMap> = {
+    initial: Fields;
+    changes: Fields;
 };
 /**
  * @description
@@ -22,22 +23,24 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
     private validator?;
     deletedItems: ItemTypeMap<ItemEntry[]>;
     itemChanges: {
-        [itemEntryId: number]: TransactionItemEntryChanges<any, any>;
+        [itemEntryId: number]: TransactionItemEntryChanges;
     };
     fieldChangeCallbacks: {
         [itemType: string]: {
-            [itemId: string]: Array<FieldChangeCallback<any, any>>;
+            [itemId: string]: FieldChangeCallback[];
         };
     };
     constructor(dependencies: TransactionItemHandlerDependencyInterface, transaction: TransactionCache, validator?: TransactionValidator | undefined);
-    registerFieldChangeCallback<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
+    registerFieldChangeCallback<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, callback: FieldChangeCallback<ItemTypeType>): DeregFunction;
     copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): TransactionItemEntryChanges;
     createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
     /**
      * @description
      * Gets the local {@link FieldMap changes} of the {@link ItemEntry entry} on the {@link TransactionCache transaction} in a formatted way the API accepts
      */
-    formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): FieldMap<ItemEntryType['itemType']>;
+    formatRequest<ItemEntryType extends ItemEntry>(entry: ItemEntryType): {
+        [columnId: string]: any;
+    };
     detectChanges(): boolean;
     /**
      * @description
@@ -61,20 +64,20 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @returns
      * The previous changes {@link FieldMap FieldMap}, returns `null` when the item was not cached or no fields were changed.
      */
-    processItemEntryChanges<ItemTypeType extends ItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
-    cloneItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
-    cloneItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
-    fetchItemEntriesByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, forceOverwrite?: boolean, updateInitial?: boolean, isCalledAfterSocketUpdate?: boolean, createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    cloneItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntries: Array<ItemEntry<ItemTypeType>>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId[];
+    cloneItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, sourceEntry: ItemEntry<ItemTypeType>, conversionMap?: ItemIdConversionMap, modifyFieldsCallback?: ModifyFieldsCallback): ItemId;
+    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
     /**
      * @description
      * Fetches a template and creates a new {@link ItemEntry ItemEntry}, will error if the ItemEntry with the given ItemId already exists
      */
-    fetchNewItemEntry<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
-    fetchItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchTitle(itemType: ItemType, itemId: ItemId): PromiseInterface<string>;
-    resolveLocalItemEntry<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    expandLocalItemEntries<ItemTypeType extends ItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchNewItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ChangesDeltaResult>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchTitle(itemType: ApiEnumItemType, itemId: ItemId): PromiseInterface<string>;
+    resolveLocalItemEntry<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    expandLocalItemEntries<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDeltaBase, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     /**
      * @description
      * Fetches the data for the passed ItemType/ItemId/columns, is able to __fetchCachedQueryItem non-local derived values.
@@ -82,8 +85,8 @@ export declare class TransactionItemHandler extends ItemHandlerBase {
      * @remark
      * Assumes the the ItemEntry with the given ItemType-ItemId is already cached
      */
-    fetchLocalItemEntryData<ItemTypeType extends ItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
-    fetchLocalItemEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchLocalItemEntryData<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, options: ItemEntryOptions): PromiseInterface<any>;
+    fetchLocalItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
     private getColumnDifference;
     private expandLocalItemEntry;
     private getLocalValues;

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

@@ -1,5 +1,6 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ItemEntry } from '../../../models/index';
-import { FieldMap, ItemType, PromiseInterface } from '../../../types/index';
+import { FieldMap, PromiseInterface } from '../../../types/index';
 import { TransactionCache, TransactionErrorLevel } from './TransactionCache';
 export interface TransactionValidatorFactory {
     construct(transaction: TransactionCache): TransactionValidator;
@@ -27,7 +28,7 @@ export declare abstract class TransactionValidator {
      * @param fields
      * @param previous
      */
-    abstract validateItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
+    abstract validateItem<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>, previous: FieldMap<ItemTypeType>): void;
     protected setGlobalError(key: string, isInvalid: boolean | PromiseInterface<boolean>, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
     protected setItemError(itemEntryId: ItemEntry['id'], columnId: string, errorKey: string, isInvalid: boolean | PromiseInterface<boolean>, fieldErrorTranslationFn: () => string, saveButtonErrorTranslationFn: () => string, level: TransactionErrorLevel): void;
     private getHash;

package/dist/types/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const ALL_PERMISSIONS = "7";
+export declare const ALL_PERMISSIONS = 7;
 export declare const COLUMN_SEPERATOR = ">";
 export declare const RENDER_AS_SEPERATOR = ":";
 export declare const NEW_PREFIX: string;

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

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

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

@@ -1,3 +1,4 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { AbstractCache, ApiRequestService, QueryService } from '../classes';
 import { CachedQueryItem } from '../classes/cache/CachedQueryHandlerBase';
 import { CollectionMatcherCachedQueryProcessor } from '../classes/cache/CollectionMatcherCachedQueryProcessor';
@@ -5,15 +6,14 @@ import { CollectionMatcherCachedCollectionProcessor } from '../classes/Collectio
 import { QueryMatcherFactory } from '../factories';
 import { PromiseLibraryInterface } from '../interfaces';
 import { CollectionResource } from '../models';
-import { ItemType } from '../types';
 export declare class CollectionMatcherFactory {
     private queryMatcherFactory;
     private queryService;
     private apiRequestService;
     private promiseService;
     constructor(queryMatcherFactory: QueryMatcherFactory, queryService: QueryService, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface);
-    constructCachedCollectionProcessor(transaction: AbstractCache, getCollections: (itemType: ItemType) => {
-        [queryString: string]: CollectionResource[];
+    constructCachedCollectionProcessor(transaction: AbstractCache, getCollections: <ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType) => {
+        [queryString: string]: Array<CollectionResource<ItemTypeType>>;
     }): CollectionMatcherCachedCollectionProcessor;
-    constructCachedQueryProcessor(transaction: AbstractCache, getQueries: (itemType: ItemType) => CachedQueryItem[]): CollectionMatcherCachedQueryProcessor;
+    constructCachedQueryProcessor(transaction: AbstractCache, getQueries: <ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType) => Array<CachedQueryItem<ItemTypeType>>): CollectionMatcherCachedQueryProcessor;
 }

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

@@ -1,9 +1,9 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ItemEntryService, KeyService, QueryService } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionResource, ItemEntry } from '../models';
 import { CollectionOptionsInterface } from '../models/CollectionOptions';
-import { ItemType } from '../types';
 import { ChangesDeltaFactory } from './ChangesDeltaFactory';
 import { CollectionEntryFactory } from './CollectionEntryFactory';
 import { ColumnSetFactory } from './ColumnSetFactory';
@@ -18,5 +18,5 @@ export declare class CollectionResourceFactory {
     queryService: QueryService;
     columnSetFactory: ColumnSetFactory;
     constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory, itemEntryService: ItemEntryService, collectionEntryFactory: CollectionEntryFactory, queryService: QueryService, columnSetFactory: ColumnSetFactory);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, transaction: TransactionCache, initialItemEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, transaction: TransactionCache, initialItemEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
 }

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

@@ -1,8 +1,9 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnExpansion } from '../classes';
 import { ColumnInfoFactory } from '../factories';
-import { ApiRequestColumns, ItemType, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumns, ResponseColumnItemTypeMap } from '../types';
 export declare class ColumnExpansionFactory {
     private columnInfoFactory;
     constructor(columnInfoFactory: ColumnInfoFactory);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): ColumnExpansion<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): ColumnExpansion<ItemTypeType>;
 }

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType, ApiFields, GetColumnType } from '@rentman/backend-types';
 import { ColumnInfo } from '../classes';
-import { ItemType, ResponseColumn, RootColumnMap } from '../types';
+import { RootColumnMap } from '../types';
 export declare class ColumnInfoFactory {
     constructor();
-    construct<ItemTypeType extends ItemType>(apiColumn: ResponseColumn, parent: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>;
-    constructFromRootMap<ItemTypeType extends ItemType>(rootColumnMap: RootColumnMap, parent?: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>[];
+    construct<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any>(apiColumn: GetColumnType<ItemTypeType, ColumnId>, parent: ColumnInfo | null): ColumnInfo<ItemTypeType>;
+    constructFromRootMap<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(rootColumnMap: RootColumnMap<ItemTypeType, ColumnIds>, parent?: ColumnInfo | null): ColumnInfo<ItemTypeType, ColumnIds[number]>[];
 }

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

@@ -1,15 +1,16 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnHandler, ColumnSet, ColumnUtil } from '../classes';
 import { ColumnInfoFactory } from '../factories';
-import { ApiRequestColumns, ItemType, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumns, ResponseColumnItemTypeMap } from '../types';
 export declare class ColumnSetFactory {
     private columnHandler;
     private columnUtil;
     private columnInfoFactory;
     constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory);
-    constructStub<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): ColumnSet<ItemTypeType>;
-    resolveStub<ItemTypeType extends ItemType>(columnSet: ColumnSet, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
-    constructFromResponse<ItemTypeType extends ItemType>(itemType: ItemType, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean): ColumnSet<ItemTypeType>;
+    constructStub<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): ColumnSet<ItemTypeType>;
+    resolveStub<ItemTypeType extends ApiEnumItemType>(columnSet: ColumnSet<ItemTypeType>, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
+    constructFromResponse<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, responseColumns: ResponseColumnItemTypeMap, enableCaching?: boolean): ColumnSet<ItemTypeType>;
     private processResponseColumns;
     private constructRequestColumnsFromRootColumnMap;
     private expandRootColumnMapFromResponseColumns;

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

@@ -1,8 +1,9 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnCache, ColumnSubsetCache, ColumnUtil } from '../classes';
-import { ApiRequestColumns, ItemType } from '../types';
+import { ApiRequestColumns } from '../types';
 export declare class ColumnSubsetCacheFactory {
     private columnUtil;
     private columnCache;
     constructor(columnUtil: ColumnUtil, columnCache: ColumnCache);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
 }

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

@@ -1,11 +1,11 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ApiFormatter, CreateCompilation, CreateRequest, KeyService } from '../classes';
 import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
 import { RequestColumnExpansionFactory } from '../factories';
-import { ItemType } from '../types';
 export declare class CreateRequestFactory {
     private apiFormatter;
     private keyService;
     private requestColumnExpansionFactory;
     constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    construct<ItemTypeType extends ItemType>(compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean): CreateRequest<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean): CreateRequest<ItemTypeType>;
 }

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

@@ -1,8 +1,8 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
 import { ColumnSetFactory } from '../factories';
 import { ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } from '../models';
-import { ItemId, ItemType } from '../types';
 export declare class ItemEntryFactory {
     apiFormatter: ApiFormatter;
     columnSetFactory: ColumnSetFactory;
@@ -11,5 +11,5 @@ export declare class ItemEntryFactory {
     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>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemId: ItemId, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
 }

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

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

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ApiFormatter, QueryMatcher } from '../classes';
-import { EntryParentNull, FieldMap, ItemType } from '../types';
+import { EntryParentNull, FieldMap } from '../types';
 export declare class QueryMatcherFactory {
     private apiFormatter;
     constructor(apiFormatter: ApiFormatter);
-    construct(itemType: ItemType, fields: FieldMap, parent: EntryParentNull): QueryMatcher;
+    construct(itemType: ApiEnumItemType, fields: FieldMap, parent: EntryParentNull): QueryMatcher;
 }

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

@@ -1,10 +1,11 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnUtil } from '../classes';
 import { ColumnSetFactory } from '../factories';
 import { Template } from '../models';
-import { ApiRequestColumnMap, ApiResponse, ItemType, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumnMap, ApiResponse, ResponseColumnItemTypeMap } from '../types';
 export declare class TemplateFactory {
     columnSetFactory: ColumnSetFactory;
     columnUtil: ColumnUtil;
     constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap): Template<ItemTypeType>;
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, response: ApiResponse, additionalRequestColumns: ApiRequestColumnMap, additionalResponseColumns: ResponseColumnItemTypeMap): Template<ItemTypeType>;
 }

package/dist/types/interfaces/ApiRequestServiceInterface.d.ts

@@ -1,11 +1,12 @@
-import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestMoveItems, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestMoveItems, PromiseInterface } from '../types';
 export interface ApiRequestServiceInterface {
-    template(itemType: ItemType, params: any): PromiseInterface<any>;
-    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<any>;
-    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<any>;
-    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: ApiRequestColumnMap): PromiseInterface<any>;
+    template(itemType: ApiEnumItemType, params: any): PromiseInterface<any>;
+    create(itemType: ApiEnumItemType, itemId: ItemId, values: any, parentType?: ApiEnumItemType, parentId?: ItemId): PromiseInterface<any>;
+    delete(itemType: ApiEnumItemType, itemIds: ItemId[]): PromiseInterface<any>;
+    updateItems(itemType: ApiEnumItemType, items: ApiRequestItemMap, columns: ApiRequestColumnMap): PromiseInterface<any>;
     requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<any>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: ApiRequestMoveItems): PromiseInterface<any>;
-    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<any>;
-    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<any>;
+    moveItems(parentType: ApiEnumItemType, parentId: ItemId, items: ApiRequestMoveItems): PromiseInterface<any>;
+    columns(itemType: ApiEnumItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<any>;
+    query(itemType: ApiEnumItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<any>;
 }

package/dist/types/interfaces/AuthInterface.d.ts

@@ -1,9 +1,10 @@
+import { ItemId } from '@rentman/backend-types';
 export interface AuthInterface {
     /**
      * @returns {string} A uniquely identifying string for each user of the api
      */
     getUniqueUserId(): string;
-    getUserId(): number;
+    getUserId(): ItemId;
     getUserAccountname(): string;
     getUserDisplayname(): string;
 }

package/dist/types/interfaces/LinkTreeServiceInterface.d.ts

@@ -1,4 +1,4 @@
-import { ApiLinkTree } from '../types';
+import { ApiLinkTree } from '..';
 export interface LinkTreeServiceInterface {
     get: () => ApiLinkTree;
 }

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

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

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

@@ -1,18 +1,24 @@
+import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
 import { CollectionResource, ItemResource } from '../models';
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ColumnIdTypeMap, EntryParentNull, FieldChangeCallback, ItemType } from '../types';
-export declare type CollectionResourceCallback<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any> = (itemResources: Array<ItemResource<ItemTypeType, Fields>>, collectionResource: CollectionResource<ItemTypeType, Fields>, isCalledAfterSocketUpdate: boolean) => void;
-export declare type CollectionResourceOnAddCallback<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any> = (itemResources: Array<ItemResource<ItemTypeType, Fields>>, collectionResource: CollectionResource<ItemTypeType, Fields>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
-export declare type CollectionOptionsInterface<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap = any> = Partial<CollectionOptions<ItemTypeType, Fields>>;
-export declare class CollectionOptions<ItemTypeType extends ItemType = any, Fields extends ColumnIdTypeMap = any> {
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, EntryParentNull, FieldChangeCallback } from '../types';
+export declare type CollectionResourceCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = (itemResources: Array<ItemResource<ItemTypeType, ColumnIds>>, collectionResource: CollectionResource<ItemTypeType, ColumnIds>, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = (itemResources: Array<ItemResource<ItemTypeType, ColumnIds>>, collectionResource: CollectionResource<ItemTypeType, ColumnIds>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionOptionsInterface<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = Partial<CollectionOptions<ItemTypeType, ColumnIds>>;
+export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> {
     columns: ApiRequestColumns;
     query: ApiQuery | null;
     queryColumns: ApiRequestColumns;
     parent: EntryParentNull;
     limit: ApiRequestLimit | null;
-    onAdd: CollectionResourceOnAddCallback<ItemTypeType, Fields>;
-    onRemove: CollectionResourceCallback<ItemTypeType, Fields>;
+    onAdd: CollectionResourceOnAddCallback<ItemTypeType, ColumnIds>;
+    onRemove: CollectionResourceCallback<ItemTypeType, ColumnIds>;
     onChange: FieldChangeCallback;
     custom: any;
     callOnAddWithInitialItems: boolean;
-    constructor(values: CollectionOptionsInterface<ItemTypeType, Fields>);
+    /**
+     * @description
+     * Prevents a CachedQueryItem from being cached (the CollectionResource will still be cached), you can use this when you fetch an Itemtype for which the backend doesn't send socket messages (so it never automatically updates)
+     */
+    preventCaching: boolean;
+    constructor(values: CollectionOptionsInterface<ItemTypeType, ColumnIds>);
 }

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

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

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

@@ -1,7 +1,7 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ColumnSet } from '../classes';
 import { ItemEntryFactory } from '../factories';
-import { ItemId, ItemType } from '../types';
-export declare class ItemEntry<ItemTypeType extends ItemType = any> {
+export declare class ItemEntry<ItemTypeType extends ApiEnumItemType = any> {
     private factory;
     itemType: ItemTypeType;
     itemId: ItemId;