@rentman/rm-core 7.2.0 → 8.0.0

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

@@ -1,10 +1,11 @@
+import { ApiEnumApiType, ApiEnumApiTypeTsTypeMapping, ApiEnumItemType, ApiFields, ResponseColumn } from '@rentman/backend-types';
 import moment from 'moment';
 import { ColumnInfo } from '../classes';
-import { ColumnIdTypeMap, FieldMap, ItemType, ResponseColumn } from '../types';
-declare type GetChangesResult<Fields extends FieldMap, key extends keyof Fields = string> = {
-    oldValue: Fields[key];
-    newValue: Fields[key];
-    column: ResponseColumn;
+import { FieldMap } from '../types';
+declare type GetChangesResult<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> = {
+    oldValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
+    newValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
+    column: ResponseColumn<ItemTypeType, ColumnId>;
 };
 export declare class ApiFormatter {
     MOMENT_INVALID: string;
@@ -20,28 +21,28 @@ export declare class ApiFormatter {
      * @remarks
      * Currently only used for Moment objects
      */
-    isExpensiveFormat(columnType: string): boolean;
+    isExpensiveFormat(columnType: ApiEnumApiType): boolean;
     /**
      * @description
      * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
      */
-    mergeCopyFields<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(initial: FieldMap<ItemTypeType, Fields>, changes: FieldMap<ItemTypeType, Fields>, newInitial: FieldMap<ItemTypeType, Fields>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType, Fields>;
-    formatRequest<Fields extends FieldMap>(initial: Fields, modified: Fields, columns: Array<ColumnInfo<any>>): {
+    mergeCopyFields<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, changes: FieldMap<ItemTypeType, ColumnIds>, newInitial: FieldMap<ItemTypeType, ColumnIds>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType, ColumnIds>;
+    formatRequest<Fields extends FieldMap>(initial: Fields, modified: Fields, columns: Array<ColumnInfo>): {
         [columnId: string]: any;
     };
-    formatRequestLocal<Fields extends FieldMap>(fields: Fields, columns: Array<ColumnInfo<any>>): {
+    formatRequestLocal<Fields extends FieldMap>(fields: Fields, columns: ColumnInfo[]): {
         [columnId: string]: any;
     };
     hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>, includeReadOnlyColumns?: boolean, forceCompare?: boolean): boolean;
-    getChanges<Fields extends FieldMap>(initial: Fields, modified: Fields, columns: Array<ColumnInfo<any>>): Array<GetChangesResult<Fields> | undefined>;
-    copyFields<Fields extends FieldMap>(source: Fields, destination: Fields, columns: Array<ColumnInfo<any>>): Fields;
+    getChanges<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, modified: FieldMap<ItemTypeType, ColumnIds>, columns: Array<ColumnInfo<ItemTypeType, ColumnIds[number]>>): Array<GetChangesResult<ItemTypeType, ColumnIds[number]>>;
+    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = any>(source: FieldMap<ItemTypeType, ColumnIds>, destination: Partial<FieldMap<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType, ColumnIds[number]>>): FieldMap<ItemTypeType, ColumnIds>;
     shallowCopyFields<Fields extends FieldMap>(shallowSource: Fields, deepSource: Fields, destination: Fields, columns: Array<ColumnInfo<any>>): Fields;
-    setDefaultValues<ItemTypeType extends ItemType = any>(destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
+    setDefaultValues<ItemTypeType extends ApiEnumItemType = any>(destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
     /**
      * @description
      * Compares the given fields, returns `true` when the fields are equal
      */
-    compareFields(columnType: string, first?: any, second?: any): boolean;
+    compareFields<ColumnType extends ApiEnumApiType>(columnType: ColumnType, first?: ApiEnumApiTypeTsTypeMapping[ColumnType], second?: ApiEnumApiTypeTsTypeMapping[ColumnType]): boolean;
     compareFloats(a: number, b: number): boolean;
     compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
     compareDurations(first: moment.Duration, second: moment.Duration): boolean;
@@ -54,8 +55,8 @@ export declare class ApiFormatter {
     formatRequestDate(value: moment.Moment): string | null;
     formatRequestDuration(value: moment.Duration): number;
     formatRequestColor(value: string): string;
-    getDefaultValue(columnType: string): any;
-    isDefaultValue(columnType: string, value: any): boolean;
+    getDefaultValue(columnType: ApiEnumApiType): any;
+    isDefaultValue(columnType: ApiEnumApiType, value: any): boolean;
     clone(columnType: string, value: any): any;
     getCloneFunction(columnType: string): ((duration: moment.Duration) => moment.Duration) | ((date: moment.Moment) => moment.Moment);
     cloneDuration(duration: moment.Duration): moment.Duration;

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

@@ -1,20 +1,21 @@
+import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
 import { ApiResponseProcessor } from '../classes';
 import { ApiResponseProcessorFactory } from '../factories';
 import { ApiRequestServiceInterface } from '../interfaces';
-import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, PromiseInterface } from '../types';
 export declare class ApiRequestService {
     private externalApiRequestService;
     private apiResponseProcessorFactory;
     constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    template(itemType: ItemType, params: any): PromiseInterface<ApiResponseProcessor>;
-    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
-    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
-    updateItems(itemType: ItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
+    template(itemType: ApiEnumItemType, params: any): PromiseInterface<ApiResponseProcessor>;
+    create(itemType: ApiEnumItemType, itemId: ItemId, values: any, parentType?: ApiEnumItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
+    delete(itemType: ApiEnumItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
+    updateItems(itemType: ApiEnumItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
     requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: {
+    moveItems(parentType: ApiEnumItemType, parentId: ItemId, items: {
         [itemType: string]: ItemId[];
     }): PromiseInterface<ApiResponseProcessor>;
-    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
-    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
+    columns(itemType: ApiEnumItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
+    query<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery<ItemTypeType>, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
     processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
 }

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

@@ -1,6 +1,7 @@
-import { ApiFormatter } from '../classes';
-import { ColumnIdTypeMap, FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
-export declare class ApiResponseProcessor<RequestItemType extends ItemType = any> {
+import { ApiEnumItemType, ItemId, ResponseColumn } from '@rentman/backend-types';
+import { ApiFormatter, ColumnInfo } from '../classes';
+import { FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, ResponseColumnMap } from '../types';
+export declare class ApiResponseProcessor<RequestItemType extends ApiEnumItemType = any> {
     apiFormatter: ApiFormatter;
     response: any;
     itemType: RequestItemType;
@@ -16,16 +17,14 @@ export declare class ApiResponseProcessor<RequestItemType extends ItemType = any
     };
     columnMap: any;
     constructor(apiFormatter: ApiFormatter, response: any);
-    fetchColumnObject(itemType: ItemType): ResponseColumn;
-    fetchValue(itemType: ItemType, itemId: ItemId, columnId: string): any;
-    fetchColumnArray(itemType: ItemType): ResponseColumn[];
-    fetchDerivedObject(itemType: ItemType, itemId: ItemId, rootColumns: ResponseColumn[]): {};
-    fetchDerivedValues(value: any, column: ResponseColumn, destination: any): void;
-    fetchObject<Fields extends ColumnIdTypeMap, ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType, Fields> | undefined;
-    fetchObjectArray<ItemTypeType extends ItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
-    fetchColumnsObject(): {
-        [itemType: string]: ResponseColumn;
-    };
+    fetchColumnObject(itemType: ApiEnumItemType): ResponseColumnMap;
+    fetchValue(itemType: ApiEnumItemType, itemId: ItemId, columnId: string): any;
+    fetchColumnArray(itemType: ApiEnumItemType): ResponseColumn[];
+    fetchDerivedObject(itemType: ApiEnumItemType, itemId: ItemId, rootColumns: ColumnInfo[]): {};
+    fetchDerivedValues(value: any, column: ColumnInfo, destination: any): void;
+    fetchObject<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType> | undefined;
+    fetchObjectArray<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
+    fetchColumnsObject(): ResponseColumnItemTypeMap;
     private addLazyFormattingFunction;
     private createColumnMaps;
 }

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

@@ -1,16 +1,18 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ItemEntry } from '../models';
-import { ItemEntryMap, ItemMap, ItemType } from '../types';
+import { ItemEntryMap, ItemMap } from '../types';
 import { TransactionCache } from './cache/transaction/TransactionCache';
 import { InternalCreateDelta } from './InternalChangesDelta';
+export declare type CreateRequestCompilationParent = ApiEnumItemType | 'Void';
 export declare type CreateCompilation = {
     [parentType: string]: {
         [parentId: number]: ItemMap<InternalCreateDelta>;
     };
 };
 export declare type DeleteCompilation = {
-    [itemType: string]: Array<ItemEntry<ItemType>>;
+    [itemType: string]: ItemEntry[];
 };
-export declare type UpdateCompilation = ItemEntryMap<ItemType>;
+export declare type UpdateCompilation = ItemEntryMap;
 export declare type MoveCompilation = {
     [parentType: string]: {
         [parentId: number]: ItemEntry[];

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

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

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

@@ -1,15 +1,15 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemEntry } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemIdConversionMap } from '../types';
 import { ItemEntryService } from './ItemEntryService';
 export declare type ChangesDeltaResult = {
-    rollback: () => void;
     created: ItemEntry[];
 };
 /**
  * @remark
  * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
  */
-export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ItemType = any> = {
+export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ApiEnumItemType = any> = {
     entry: ItemEntry<ItemTypeType>;
     changes: {
         expandedColumns: ColumnExpansionResult<ItemTypeType> | null;
@@ -43,8 +43,8 @@ export declare abstract class ChangesDeltaBase {
      *
      * @private
      */
-    _setQueryResult(itemType: ItemType, queryString: string, itemIds: ItemId[]): void;
-    setItemUpdated<ItemEntryType extends ItemEntry>(entry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>, columnExpansionResult?: ColumnExpansionResult<ItemEntryType['itemType']> | null, parent?: EntryParentNull): this;
+    _setQueryResult(itemType: ApiEnumItemType, queryString: string, itemIds: ItemId[]): void;
+    setItemUpdated<ItemTypeType extends ApiEnumItemType>(entry: ItemEntry<ItemTypeType>, fields: Partial<FieldMap<ItemTypeType>>, columnExpansionResult?: ColumnExpansionResult<ItemTypeType> | null, parent?: EntryParentNull): this;
     setItemDeleted(deleted: ItemEntry): this;
     setItemsDeleted(deleted: ItemEntry[]): this;
     isEmpty(): boolean;

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

@@ -1,17 +1,18 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { QueryService } from '../classes';
 import { QueryParserFactory } from '../factories';
 import { ItemEntry } from '../models';
 import { CollectionOptions, CollectionOptionsInterface } from '../models/CollectionOptions';
-import { ApiQuery, CollectionQuery, EntryParentNull, ItemId, ItemType } from '../types';
+import { ApiQuery, CollectionQuery, EntryParentNull } from '../types';
 export declare class CollectionEntryService {
     private queryParserFactory;
     private queryService;
     constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
-    createUnfoundLocalCollectionError(itemType: ItemType): {
+    createUnfoundLocalCollectionError(itemType: ApiEnumItemType): {
         message: string;
     };
-    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any, any>;
-    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions;
+    cloneOptions(options: CollectionOptions, parent: EntryParentNull): CollectionOptions<any, (string | number | symbol)[]>;
+    processOptions<ItemTypeType extends ApiEnumItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions;
     createQuery(query: ApiQuery): CollectionQuery;
     createQueryFromOptions(options: CollectionOptions): CollectionQuery;
     getIdArray(itemEntries: Array<ItemEntry<any>>, accumulator?: ItemId[]): ItemId[];

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

@@ -1,9 +1,10 @@
-import { AbstractCache, CollectionQuery, FieldMap, ItemType, QueryService } from '../';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, CollectionQuery, FieldMap, QueryService } from '../';
 import { QueryMatcherFactory } from '../factories/';
 import { ItemEntry } from '../models';
 import { GroupedCollectionMatcherResult } from './cache/CollectionMatcherCachedQueryProcessor';
 import { InternalChangesDelta } from './InternalChangesDelta';
-export declare type CollectionMatcherMatches<ItemTypeType extends ItemType = ItemType> = {
+export declare type CollectionMatcherMatches<ItemTypeType extends ApiEnumItemType = any> = {
     [itemId: number]: {
         item: ItemEntry<ItemTypeType>;
         isMatch: boolean | 'maybe';
@@ -16,6 +17,6 @@ export declare abstract class CollectionMatcherBase {
     protected constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
     expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
     processDelta(internalChangesDelta: InternalChangesDelta): this;
-    protected groupItemEntries<ItemTypeType extends ItemType>(matches: CollectionMatcherMatches<ItemTypeType>): GroupedCollectionMatcherResult<ItemTypeType>;
-    protected abstract _expand<ItemTypeType extends ItemType = string>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+    protected groupItemEntries<ItemTypeType extends ApiEnumItemType>(matches: CollectionMatcherMatches<ItemTypeType>): GroupedCollectionMatcherResult<ItemTypeType>;
+    protected abstract _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
 }

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { QueryMatcherFactory } from '../factories';
 import { PromiseLibraryInterface } from '../interfaces';
 import { CollectionResource, ItemEntry } from '../models';
-import { CollectionQuery, ItemType, PromiseInterface } from '../types';
+import { CollectionQuery, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
 import { AbstractCache } from './cache/AbstractCache';
 import { ChangesDeltaBase } from './ChangesDeltaBase';
@@ -17,15 +18,15 @@ export declare class CollectionMatcherCachedCollectionProcessor extends Collecti
     private getCollections;
     protected map: {
         [itemTypeAndQueryString: string]: {
-            itemType: ItemType;
+            itemType: ApiEnumItemType;
             query: CollectionQuery;
             collectionResources: CollectionResource[];
             matches: CollectionMatcherMatches;
         };
     };
-    constructor(apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollections: (itemType: ItemType) => {
-        [queryString: string]: CollectionResource[];
+    constructor(apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache, getCollections: <ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType) => {
+        [queryString: string]: Array<CollectionResource<ItemTypeType>>;
     });
     __removeFromAndAddToCollections(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 = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
 }

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

@@ -1,7 +1,7 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { CollectionOptions, ItemResource } from '../models';
 import { CollectionOptionsInterface } from '../models/CollectionOptions';
-import { ItemId, ItemType } from '../types';
 export declare class CollectionResourceService {
-    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions<ItemTypeType>;
+    processOptions<ItemTypeType extends ApiEnumItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionOptions<ItemTypeType>;
     getIdArray(itemResources: ItemResource[]): ItemId[];
 }

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

@@ -1,5 +1,6 @@
+import { ApiEnumItemType, ResponseColumn } from '@rentman/backend-types';
 import { ColumnUtil } from '../classes';
-import { ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumns, ResponseColumnItemTypeMap } from '../types';
 export declare class ColumnCache {
     private columnUtil;
     cache: ResponseColumnItemTypeMap;
@@ -7,15 +8,15 @@ export declare class ColumnCache {
         [itemType: string]: boolean;
     };
     constructor(columnUtil: ColumnUtil);
-    setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
-    setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): ResponseColumnItemTypeMap;
-    retrieve(itemType: ItemType, requestColumns: ApiRequestColumns): {
+    setColumn(itemType: ApiEnumItemType, responseColumn: ResponseColumn): ResponseColumn;
+    setColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, columnFilter: string | false): ResponseColumnItemTypeMap;
+    retrieve(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns): {
         cached: ResponseColumnItemTypeMap;
         missing: ApiRequestColumns;
     };
-    containsAll(itemType: ItemType): boolean;
-    getColumns(itemType: ItemType): ResponseColumnItemTypeMap;
-    getColumn(itemType: ItemType, columnId: string): ResponseColumn | undefined;
+    containsAll(itemType: ApiEnumItemType): boolean;
+    getColumns(itemType: ApiEnumItemType): ResponseColumnItemTypeMap;
+    getColumn(itemType: ApiEnumItemType, columnId: string): ResponseColumn | undefined;
     private retrieveColumns;
     private retrieveColumn;
 }

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

@@ -1,11 +1,12 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnInfo, ColumnSet } from '../classes';
 import { ColumnInfoFactory } from '../factories';
-import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ResponseColumnItemTypeMap } from '../types';
 /**
  * @description
  * A ColumnExpansion is used to make sure {@link ItemEntry ItemEntries} that have the same {@link ColumnSet ColumnSet} (matched on {@link ColumnSet.id ColumnSet.id}) will all get the same new expanded ColumnSet
  */
-export declare class ColumnExpansion<ItemTypeType extends ItemType> {
+export declare class ColumnExpansion<ItemTypeType extends ApiEnumItemType> {
     private columnInfoFactory;
     itemType: ItemTypeType;
     responseColumns: ResponseColumnItemTypeMap;

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

@@ -1,6 +1,7 @@
+import { ApiEnumItemType, ResponseColumn } from '@rentman/backend-types';
 import { ApiRequestService, ColumnCache, ColumnUtil } from '../classes';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemType, PromiseInterface, ResponseColumn, ResponseColumnItemTypeMap } from '../types';
+import { ApiRequestColumns, PromiseInterface, ResponseColumnItemTypeMap } from '../types';
 export declare class ColumnHandler {
     private apiRequestService;
     private errorHandler;
@@ -8,14 +9,14 @@ export declare class ColumnHandler {
     private cache;
     private columnUtil;
     constructor(apiRequestService: ApiRequestService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, cache: ColumnCache, columnUtil: ColumnUtil);
-    setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
-    setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap): ResponseColumnItemTypeMap;
-    fetchItemTypeTranslations(itemTypes: ItemType[]): PromiseInterface<{
+    setColumn(itemType: ApiEnumItemType, responseColumn: ResponseColumn): ResponseColumn;
+    setColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, filter?: string | false): ResponseColumnItemTypeMap;
+    fetchItemTypeTranslations(itemTypes: ApiEnumItemType[]): PromiseInterface<{
         [itemType: string]: string;
     }>;
-    request(itemType: ItemType, columns: ApiRequestColumns, params?: {
-        filter: boolean;
+    request(itemType: ApiEnumItemType, columns: ApiRequestColumns, params?: {
+        filter: string | false;
     }): PromiseInterface<ResponseColumnItemTypeMap>;
-    fetch(itemType: ItemType, requestColumns: ApiRequestColumns, params?: any): PromiseInterface<ResponseColumnItemTypeMap>;
-    fetchAll(itemType: ItemType): PromiseInterface<ResponseColumnItemTypeMap>;
+    fetch(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns, params?: any): PromiseInterface<ResponseColumnItemTypeMap>;
+    fetchAll(itemType: ApiEnumItemType): PromiseInterface<ResponseColumnItemTypeMap>;
 }

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

@@ -1,14 +1,14 @@
-import { ItemType, ResponseColumn } from '../types';
-export declare class ColumnInfo<ItemTypeType extends ItemType = any> {
-    readonly apiColumn: ResponseColumn;
-    readonly parent: ColumnInfo<ItemType> | null;
-    id: string;
+import { ApiEnumItemType, ApiFields, GetColumnType } from '@rentman/backend-types';
+export declare class ColumnInfo<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> {
+    readonly apiColumn: GetColumnType<ItemTypeType, ColumnId>;
+    readonly parent: ColumnInfo | null;
+    id: ColumnId;
     level: number;
     path: string;
     tailPath: string;
     itemType: ItemTypeType | null;
     children: Array<ColumnInfo<ItemTypeType>>;
     isLeaf: boolean;
-    constructor(apiColumn: ResponseColumn, parent?: ColumnInfo<ItemType> | null);
+    constructor(apiColumn: GetColumnType<ItemTypeType, ColumnId>, parent?: ColumnInfo | null);
     setChildren(itemType: ItemTypeType, children: Array<ColumnInfo<ItemTypeType>>): this;
 }

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
 import { ColumnSetFactory } from '../factories';
-import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnItemTypeMap } from '../types';
-export declare class ColumnSet<ItemTypeType extends ItemType = any> {
+import { ApiRequestColumns, ColumnExpansionResult, ResponseColumnItemTypeMap } from '../types';
+export declare class ColumnSet<ItemTypeType extends ApiEnumItemType = any> {
     private columnUtil;
     private columnSetFactory;
     itemType: ItemTypeType;
@@ -26,8 +27,8 @@ export declare class ColumnSet<ItemTypeType extends ItemType = any> {
     constructor(columnUtil: ColumnUtil, columnSetFactory: ColumnSetFactory, itemType: ItemTypeType);
     groupColumnInfo(columnInfo: ColumnInfo): void;
     toJSON(): {
-        main: string[];
-        derived: string[];
+        main: any[];
+        derived: any[];
     };
     isSupersetOf(columnsToCompare: ApiRequestColumns): boolean;
     private getMergedColumnSet;

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

@@ -1,6 +1,7 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ColumnCache, ColumnSet, ColumnUtil } from '../classes';
-import { ApiRequestColumn, ApiRequestColumns, ItemType } from '../types';
-export declare class ColumnSubsetCache<ItemTypeType extends ItemType> {
+import { ApiRequestColumn, ApiRequestColumns } from '../types';
+export declare class ColumnSubsetCache<ItemTypeType extends ApiEnumItemType> {
     private columnUtil;
     private columnCache;
     itemType: ItemTypeType;

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

@@ -1,5 +1,6 @@
+import { ApiEnumApiType, ApiEnumItemType, ApiFields, ResponseColumn, ResponseColumnCustom, ResponseColumnItem } from '@rentman/backend-types';
 import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
-import { ApiRequestColumn, ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnItemTypeMap, ResponseColumnMap } from '../types';
+import { ApiRequestColumn, ApiRequestColumns, ResponseColumnItemTypeMap, ResponseColumnMap } from '../types';
 export declare type RequestColumnMergeResult<T extends ApiRequestColumns = ApiRequestColumns, U extends ApiRequestColumns = ApiRequestColumns> = {
     merged: T;
     difference: U;
@@ -15,25 +16,25 @@ export declare class ColumnUtil {
      * - For {@link ApiLinkTreeType.DIRECT direct links} it will be a columnId
      * - For {@link ApiLinkTreeType.ITEMTABLE itemtable links} it will be 'itemtype' and 'item'
      */
-    getColumnsFromLink(parentType: ItemType, itemType: ItemType): ApiRequestColumn[];
+    getColumnsFromLink(parentType: ApiEnumItemType, itemType: ApiEnumItemType): ApiRequestColumn[];
     getColumnPath(columns: ResponseColumn[], renderAs: null | string): string;
     getDateFormatOptions(columnType?: 'datetime'): {
         'J-M-Y': string;
         'J-M': string;
         'j+F+Y': string;
         'D+j+F+Y': string;
-        'F': string;
-        'f': string;
-        'D': string;
-        'd': string;
+        F: string;
+        f: string;
+        D: string;
+        d: string;
     };
     isStringColumn(column: ResponseColumn): boolean;
     isFloatColumn(column: ResponseColumn): boolean;
     isIntColumn(column: ResponseColumn): boolean;
     isNumberColumn(column: ResponseColumn): boolean;
-    isCustomColumn(column: ResponseColumn): boolean;
+    isCustomColumn<ItemTypeType extends ApiEnumItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(column: ResponseColumn<ItemTypeType, ColumnId>): column is ResponseColumnCustom<ItemTypeType, ColumnId>;
     isAggregateColumn(column: ResponseColumn): boolean;
-    isItemColumn(column: ResponseColumn, includeId?: boolean): boolean;
+    isItemColumn<ItemTypeType extends ApiEnumItemType, ColumnId extends keyof ApiFields[ItemTypeType]>(column: ResponseColumn<ItemTypeType, ColumnId>, includeId?: boolean): column is ResponseColumnItem<ItemTypeType, ColumnId>;
     isDateColumn(column: ResponseColumn): boolean;
     isRenderedColumn(column: ResponseColumn): boolean;
     isFilteredColumn(column: ResponseColumn): boolean;
@@ -44,15 +45,15 @@ export declare class ColumnUtil {
     isSearchableColumn(column: ResponseColumn): boolean;
     getDefaultWeight(column: ResponseColumn): number;
     getComparators(column: ResponseColumn & {
-        type: 'dimension' | 'weight' | 'price';
+        type: ApiEnumApiType.TYPE_DIMENSION | ApiEnumApiType.TYPE_WEIGHT | ApiEnumApiType.TYPE_PRICE;
     }): ['=', '>', '<'];
     getComparators(column: ResponseColumn & {
-        type: 'date' | 'datetime' | 'time' | 'duration';
+        type: ApiEnumApiType.TYPE_DATE | ApiEnumApiType.TYPE_DATETIME | ApiEnumApiType.TYPE_DURATION;
     }): ['>', '<'];
     getComparators(column: ResponseColumn): ['=', '!='];
     containsColumn(requestColumn: ApiRequestColumn, destination: ApiRequestColumn[]): boolean;
     containsDerivedColumns(requestColumns: ApiRequestColumn[]): boolean;
-    responseColumnsAvailable(itemType: ItemType, requestColumns: ApiRequestColumn[], responseColumnMap: ResponseColumnItemTypeMap): boolean;
+    responseColumnsAvailable(itemType: ApiEnumItemType, requestColumns: ApiRequestColumn[], responseColumnMap: ResponseColumnItemTypeMap): boolean;
     copyRequestColumns(columns: true): true;
     copyRequestColumns(columns: ApiRequestColumn[]): ApiRequestColumn[];
     copyRequestColumn(requestColumn: ApiRequestColumn): ApiRequestColumn;

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

@@ -1,5 +1,6 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ItemEntry } from '../models';
-import { ApiResponse, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType } from '../types';
+import { ApiResponse, EntryParentNull, FieldMap, ItemIdConversionMap } from '../types';
 import { ColumnInfo } from './ColumnInfo';
 import { KeyService } from './KeyService';
 /**
@@ -12,16 +13,16 @@ import { KeyService } from './KeyService';
 export declare class ConversionMapService {
     private keyService;
     constructor(keyService: KeyService);
-    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
-    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
+    createLocalConversionMap(itemType: ApiEnumItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
+    expandLocalConversionMap(parentType: ApiEnumItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
     expandConversionMap(itemEntry: ItemEntry, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
     batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
-    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    getConversionValue(itemType: ApiEnumItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
     /**
      * @description
      * Updates the columns in `fields` using the `parent` and `conversionMap`.
      * @param parent - When retrieving an item the 'link' column is not present in the template response, and is
      * added at a later stage. The value for this column can be read from this parameter.
      */
-    updateItemValues<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap, parent?: EntryParentNull): void;
+    updateItemValues<ItemTypeType extends ApiEnumItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, itemColumns: Array<ColumnInfo<ItemTypeType>>, conversionMap: ItemIdConversionMap, parent?: EntryParentNull): void;
 }

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

@@ -1,8 +1,9 @@
-import { ApiFormatter, CreateCompilation, KeyService } from '../classes';
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiFormatter, CreateCompilation, CreateRequestCompilationParent, KeyService } from '../classes';
 import { RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestEntry, ItemType } from '../types';
+import { CreateRequestEntry } from '../types';
 import { TransactionCache } from './cache/transaction/TransactionCache';
-export declare class CreateRequest<ItemTypeType extends ItemType> {
+export declare class CreateRequest<ItemTypeType extends ApiEnumItemType> {
     private apiFormatter;
     private keyService;
     private requestColumnExpansionFactory;
@@ -12,7 +13,7 @@ export declare class CreateRequest<ItemTypeType extends ItemType> {
     requests: Array<CreateRequestEntry<ItemTypeType>>;
     constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean);
     finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
-    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
+    setRequestParent(parentType: CreateRequestCompilationParent, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
     run(): CreateRequestEntry<ItemTypeType>[];
     initializeRequest(): CreateRequestEntry<ItemTypeType>;
     private extendRequest;

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

@@ -1,6 +1,7 @@
-import { FieldMap, ItemId, ItemType } from '../types';
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { FieldMap } from '../types';
 import { ColumnSet } from './ColumnSet';
-export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
+export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ApiEnumItemType = any> = {
     itemId: ItemId;
     fields: FieldMap<ItemTypeType>;
     columns: ColumnSet<ItemTypeType>;
@@ -8,9 +9,9 @@ export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType =
 export declare class CreatedChangesDelta {
     private tuples;
     constructor();
-    remove(itemType: ItemType, itemId: ItemId): boolean;
-    add<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>): void;
+    remove(itemType: ApiEnumItemType, itemId: ItemId): boolean;
+    add<ItemTypeType extends ApiEnumItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>): void;
     isEmpty(): boolean;
-    forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ItemType, index: number) => void): void;
-    contains(itemType: ItemType): boolean;
+    forEach(callback: (tuple: ChangesDeltaItemCreateDelta, itemType: ApiEnumItemType, index: number) => void): void;
+    contains(itemType: ApiEnumItemType): boolean;
 }

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

@@ -1,8 +1,9 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ItemEntry } from '../models';
-import { EntryParent, FieldMap, ItemIdConversionMap, ItemType } from '../types';
+import { EntryParent, FieldMap, ItemIdConversionMap } from '../types';
 import { ChangesDeltaBase } from './ChangesDeltaBase';
 import { ItemEntryService } from './ItemEntryService';
-export declare type InternalCreateDelta<ItemTypeType extends ItemType = any> = {
+export declare type InternalCreateDelta<ItemTypeType extends ApiEnumItemType = any> = {
     entry: ItemEntry<ItemTypeType>;
     fields: FieldMap<ItemTypeType>;
 };
@@ -29,7 +30,7 @@ export declare class InternalChangesDelta extends ChangesDeltaBase {
     };
     itemIdConversionMap: ItemIdConversionMap;
     constructor(itemEntryService: ItemEntryService);
-    setItemCreated<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
+    setItemCreated<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
     /**
      * @remark
      * Parent fields are non-writable so we need to keep track of moved entries another way (to do a linkTo request)