@rentman/rm-core 8.1.9 → 8.2.1

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

@@ -1,11 +1,5 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
 import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
-export declare type CacheSyncerMatches<ItemTypeType extends ApiEnumItemType = any> = {
-    [itemId: number]: {
-        item: ItemEntry<ItemTypeType>;
-        isMatch: boolean | 'maybe';
-    };
-};
 export declare type CacheSyncerQueryMap = ItemTypeMap<{
     [cachedQueryString: string]: {
         cachedQueryItems: CachedQueryItem[];
@@ -18,17 +12,25 @@ export declare class CacheSyncer {
     private apiRequestService;
     private promiseService;
     private transaction;
-    private queryStringMap;
-    private map;
-    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, queryStringMap: CacheSyncerQueryMap);
-    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
+    private cachedQueryMap;
+    private matchedItemEntryMap;
+    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
+    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
     syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
     expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
     processDelta(parentChangesDelta: ParentChangesDelta): this;
-    protected groupItemEntries<ItemTypeType extends ApiEnumItemType>(matches: CacheSyncerMatches<ItemTypeType>): {
-        fitting: ItemEntry<ItemTypeType>[];
-        notFitting: ItemEntry<ItemTypeType>[];
-        maybe: ItemEntry<ItemTypeType>[];
-    };
+    /**
+     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
+     */
+    private resolveAll;
+    private syncCollection;
+    private syncCachedQuery;
+    private groupItemEntries;
     protected _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+    /**
+     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
+     * by the caller.
+     */
+    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    private addMatchedEntriesToCollections;
 }

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

@@ -1,7 +1,6 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, RmCore, Template, TemplateFactory } from '../internal';
+import { ApiRequestService, ApiResponse, ColumnHandler, ColumnUtil, EntryParentNull, ErrorHandlerInterface, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, Template, TemplateFactory } from '../internal';
 export declare class TemplateCache {
-    private core;
     private columnUtil;
     private promiseService;
     private columnHandler;
@@ -13,7 +12,7 @@ export declare class TemplateCache {
     templateResponses: {
         [itemType: string]: ApiResponse;
     };
-    constructor(core: RmCore, columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
+    constructor(columnUtil: ColumnUtil, promiseService: PromiseLibraryInterface, columnHandler: ColumnHandler, templateFactory: TemplateFactory, errorHandler: ErrorHandlerInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService);
     /**
      * @description
      * Fetches a {@link Template template}, use {@link ItemCreateService.createItemsFromValues createItemsFromValues} to easily create new items from a set of values.

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

@@ -1,8 +1,5 @@
 import { PromiseInterface } from '../internal';
 export declare function findIndex<T>(haystack: T[], callback: (item: T) => boolean): number;
-export declare function instantiateOptions(options: {
-    [key: string]: any;
-}, values: object): void;
 export declare function shallowMerge(object: any, defaults: any): any;
 export declare function hasProperties(object: any): boolean;
 export declare function getFirstProperty(object: any): string | null;

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

@@ -1,5 +1,9 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { AbstractCache, ApiQuery, ApiRequestColumns, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnUtil, ItemEntry, ParentIdMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory } from '../../internal';
+import { AbstractCache, ApiQuery, ApiRequestColumns, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnUtil, ItemEntry, ParentIdMap, ParentItemMap, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory } from '../../internal';
+export declare type CachedQueryItemTree<ItemTypeType extends ApiEnumItemType = any> = {
+    item: CachedQueryItem<ItemTypeType>;
+    children: ParentItemMap<CachedQueryItemTree> | null;
+};
 export declare abstract class CachedQueryHandlerBase {
     protected collectionEntryService: CollectionEntryService;
     protected columnUtil: ColumnUtil;

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, ChangesDelta, ChangesDeltaResult, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+import { AbstractCache, AbstractCacheDependencyInterface, ApiQuery, ApiRequestColumn, ApiRequestColumns, CachedQueryItem, CachedQueryItemTree, ChangesDelta, ChangesDeltaResult, ChildCollectionOptions, ChildCollectionResources, ChildCollectionResourcesNull, CollectionDefinition, CollectionOptionsInterface, CollectionQuery, CollectionResource, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, DeregFunction, EntryParentNull, FieldChangeCallback, FieldMap, InternalChangesDelta, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ItemOptionsInterface, ItemResource, ItemResourcesItemTypeMap, ItemTypeMap, LinkCollectionDefinition, ModuleChangesCompilationResult, OnAfterCreateCallback, ParentChangesDelta, ParentItemMap, PromiseInterface, RmCore, ServerCache, TransactionCacheCallbackCondition, TransactionCacheCallbackType, TransactionCachedQueryHandler, TransactionCollectionHandler, TransactionEventHandler, TransactionItemEntryChanges, TransactionItemHandler, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
 declare type ItemResourceLinks<ItemTypeType extends ApiEnumItemType> = {
     main: ItemResource<ItemTypeType>;
     linked: ItemResourcesItemTypeMap;
@@ -227,6 +227,9 @@ export declare class TransactionCache extends AbstractCache {
     }, conversionMap: ConversionMap): void;
     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>>;
+    /**
+     * @deprecated Use the `children` collection option instead.
+     */
     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>>;
@@ -297,10 +300,12 @@ export declare class TransactionCache extends AbstractCache {
      * won't be included
      */
     getDelta(): InternalChangesDelta;
-    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, 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>>;
+    createItemResource<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>, childCollectionMap?: ChildCollectionResourcesNull, isNew?: boolean): ItemResource<ItemTypeType>;
+    createItemResources<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]>>(itemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ChildCollectionResourcesNull): 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>;
+    createCollectionResource<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, initialEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap?: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
+    createChildCollectionResources(parentType: ApiEnumItemType, options: ChildCollectionOptions, cachedQueryItems: ParentItemMap<CachedQueryItemTree>): ChildCollectionResources;
+    private createChildCollectionResource;
     getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: TransactionItemEntryChanges<FieldMap<ItemTypeType>>): FieldMap<ItemTypeType>;
     /**
      * @description

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, CachedQueryHandlerBase, CachedQueryItem, CollectionOptions, CollectionQuery, ColumnSubsetCache, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ParentIdMap, PromiseInterface, TransactionCache, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
+import { ApiQuery, ApiRequestColumns, CachedQueryHandlerBase, CachedQueryItem, CachedQueryItemTree, ChildCollectionOptions, CollectionOptions, CollectionQuery, ColumnSubsetCache, ItemEntry, ItemEntryOptions, ItemIdConversionMap, ParentIdMap, ParentItemMap, PromiseInterface, TransactionCache, TransactionCollectionHandlerDependencyInterface, TransactionItemHandler } from '../../../internal';
 export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBase {
     private dependencies;
     private itemHandler;
@@ -26,4 +26,6 @@ export declare class TransactionCachedQueryHandler extends CachedQueryHandlerBas
     private expandCachedQueryItemEntries;
     private syncCachedQueryWithLocalItems;
     __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __fetchParentCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItemTree<ItemTypeType>>;
+    __fetchChildCachedQueryItems(parentType: ApiEnumItemType, parentIds: ItemId[], childCollectionOptions: ChildCollectionOptions): PromiseInterface<ParentItemMap<CachedQueryItemTree>>;
 }

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

@@ -13,7 +13,7 @@ export declare class TransactionCollectionHandler {
     constructor(itemHandler: TransactionItemHandler, cachedQueryHandler: TransactionCachedQueryHandler, dependencies: TransactionCollectionHandlerDependencyInterface, transaction: TransactionCache);
     updateLocalItemIdReferences(conversionMap: ItemIdConversionMap): void;
     expandCollectionResource<ItemTypeType extends ApiEnumItemType = any>(collectionResource: CollectionResource<ItemTypeType>, newColumns: ApiRequestColumns): PromiseInterface<void>;
-    addResource(resource: CollectionResource): void;
+    addResource(resource: CollectionResource): CollectionResource;
     clearResource(resource: CollectionResource): void;
     /**
      * @description

package/dist/types/core.d.ts

@@ -42,3 +42,4 @@ export declare class RmCore {
 }
 export declare function noop(): void;
 export declare function identity(value: any): any;
+export declare function nullFunction(): null;

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

@@ -1,5 +1,5 @@
 import { ApiEnumItemType } from '@rentman/backend-types';
-import { ChangesDeltaFactory, CollectionEntryFactory, CollectionOptionsInterface, CollectionResource, ColumnSetFactory, ErrorHandlerInterface, ExceptionHandlerInterface, ItemEntry, ItemEntryService, KeyService, PromiseLibraryInterface, QueryService, TransactionCache } from '../internal';
+import { ChangesDeltaFactory, CollectionEntryFactory, CollectionOptions, CollectionResource, ColumnSetFactory, ErrorHandlerInterface, ExceptionHandlerInterface, ItemEntry, ItemEntryService, KeyService, ParentItemMap, PromiseLibraryInterface, QueryService, TransactionCache } from '../internal';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     exceptionHandler: ExceptionHandlerInterface;
@@ -11,5 +11,8 @@ 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 ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>, transaction: TransactionCache, initialItemEntries: Array<ItemEntry<ItemTypeType>>): CollectionResource<ItemTypeType>;
+    /**
+     * @internal
+     */
+    construct<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, transaction: TransactionCache, initialItemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap: ParentItemMap<CollectionResource> | null): CollectionResource<ItemTypeType>;
 }

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

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

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

@@ -1,23 +1,42 @@
 import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestLimit, CollectionResource, EntryParentNull, FieldChangeCallback, ItemResource } from '../internal';
-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]>> {
+import { ApiQuery, ApiRequestColumns, ApiRequestLimit, ChildCollectionResourcesNull, CollectionResource, EntryParentNull, FieldChangeCallback, ItemResource } from '../internal';
+export declare type CollectionResourceOnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any> = (itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>, collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isCalledAfterSocketUpdate: boolean) => void;
+export declare type CollectionResourceOnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any> = (itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>, collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>, isInitialCall: boolean, isCalledAfterSocketUpdate: boolean) => void;
+export declare type ChildCollectionOptions = {
+    [ChildItemType in ApiEnumItemType]?: CollectionOptions<ChildItemType>;
+};
+export interface CollectionOptionsInterface<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, ColumnIds>;
+    onRemove?: CollectionResourceOnRemoveCallback<ItemTypeType, ColumnIds>;
+    onChange?: FieldChangeCallback;
+    custom?: any;
+    callOnAddWithInitialItems?: boolean;
+    children?: {
+        [ChildItemType in ApiEnumItemType]?: CollectionOptionsInterface<ChildItemType>;
+    } | null;
+    preventCaching?: boolean;
+}
+export declare class CollectionOptions<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> implements Required<CollectionOptionsInterface> {
     columns: ApiRequestColumns;
     query: ApiQuery | null;
     queryColumns: ApiRequestColumns;
     parent: EntryParentNull;
     limit: ApiRequestLimit | null;
     onAdd: CollectionResourceOnAddCallback<ItemTypeType, ColumnIds>;
-    onRemove: CollectionResourceCallback<ItemTypeType, ColumnIds>;
+    onRemove: CollectionResourceOnRemoveCallback<ItemTypeType, ColumnIds>;
     onChange: FieldChangeCallback;
     custom: any;
     callOnAddWithInitialItems: boolean;
+    children: ChildCollectionOptions | null;
     /**
      * @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>);
+    constructor(optionsInterface: CollectionOptionsInterface<ItemTypeType, ColumnIds>);
 }

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

@@ -1,13 +1,15 @@
 import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ApiRequestLimit, ChangesDeltaResult, CollectionEntry, CollectionOptions, CollectionResourceFactory, CompareFieldCallback, DeregFunction, FieldMap, ItemEntry, ItemResource, ItemResourceItemIdMap, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache } from '../internal';
-export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> {
+import { ApiRequestLimit, ChangesDeltaResult, ChildCollectionResourcesNull, CollectionEntry, CollectionOptions, CollectionResourceFactory, CompareFieldCallback, DeregFunction, FieldMap, ItemEntry, ItemResource, OnAddCallback, OnChangeCallback, OnRemoveCallback, PromiseInterface, ResponseColumnItemTypeMap, TransactionCache } from '../internal';
+export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any> {
     protected factory: CollectionResourceFactory;
     options: CollectionOptions<ItemTypeType, ColumnIds>;
     transaction: TransactionCache;
     entry: CollectionEntry<ItemTypeType, ColumnIds>;
     columns: ResponseColumnItemTypeMap;
-    items: Array<ItemResource<ItemTypeType, ColumnIds>>;
-    protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType, ColumnIds>>;
+    items: Array<ItemResource<ItemTypeType, ColumnIds, Children>>;
+    protected itemIdMap: {
+        [itemId: number]: ItemResource<ItemTypeType, ColumnIds, Children>;
+    };
     private fieldChangeDeregFns;
     private readonly onChangeCallbacks;
     private readonly onAddCallbacks;
@@ -17,7 +19,7 @@ export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = a
      * 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, ColumnIds>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: Array<ItemEntry<ItemTypeType>>);
+    constructor(factory: CollectionResourceFactory, options: CollectionOptions<ItemTypeType, ColumnIds>, transaction: TransactionCache, itemType: ItemTypeType, initialItemEntries: Array<ItemEntry<ItemTypeType>>, childCollectionResourceMap: Children);
     onConstruct(): void;
     /**
      * @description
@@ -25,9 +27,9 @@ export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = a
      */
     refresh(): PromiseInterface<void>;
     setLimit(newLimit: number | ApiRequestLimit): void;
-    onAdd(callback: OnAddCallback<ItemTypeType, ColumnIds>): DeregFunction;
+    onAdd(callback: OnAddCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
     onChange(callback: OnChangeCallback<ItemTypeType, ColumnIds>): DeregFunction;
-    onRemove(callback: OnRemoveCallback<ItemTypeType, ColumnIds>): DeregFunction;
+    onRemove(callback: OnRemoveCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
     __clear(): void;
     /**
      * @deprecated
@@ -39,26 +41,37 @@ export declare class CollectionResource<ItemTypeType extends ApiEnumItemType = a
     addItems(valuesArray: Array<Partial<FieldMap<ItemTypeType, ColumnIds>>>): PromiseInterface<ChangesDeltaResult>;
     addItem(values: Partial<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
     getIdArray(): ItemId[];
-    getItemById(itemId: ItemId): ItemResource<ItemTypeType, ColumnIds>;
-    addItemResources(itemEntriesToBeAdded: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): Array<ItemResource<ItemTypeType, ColumnIds>>;
+    getItemById(itemId: ItemId): ItemResource<ItemTypeType, ColumnIds, Children>;
+    /**
+     * Creates item resources and adds them to the `items` array.
+     * @param itemEntriesToBeAdded
+     */
+    addItemEntries(itemEntriesToBeAdded: Array<ItemEntry<ItemTypeType>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): PromiseInterface<Array<ItemResource<ItemTypeType, ColumnIds, Children>>>;
+    /**
+     * Creates item resources and adds them to the `items` array. This function is also called when the collection
+     * resource is constructed. When adding item resources to the collection externally, {@link addItemEntries} should
+     * be called.
+     * @param itemEntriesToBeAdded - These item entries are assumed not to be in the collection yet.
+     */
+    private addItemResources;
     /**
      * @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, ColumnIds>>;
-    callOnAdd(itemResources: Array<ItemResource<ItemTypeType, ColumnIds>>, isInitialCall?: boolean, isCalledAfterSocketUpdate?: boolean): void;
+    removeItemResources(itemEntries: Array<ItemEntry<ItemTypeType>>, isCalledAfterSocketUpdate: boolean): Array<ItemResource<ItemTypeType, ColumnIds, Children>>;
+    callOnAdd(itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>, 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>>;
+    callOnRemove(itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>, isCalledAfterSocketUpdate: boolean): void;
+    forEach(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => void): void;
+    filter(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): Array<ItemResource<ItemTypeType, ColumnIds, Children>>;
+    first(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): ItemResource<ItemTypeType, ColumnIds, Children> | null;
+    some(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => boolean): boolean;
+    groupBy(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => string | null)): {
+        [key: string]: Array<ItemResource<ItemTypeType, ColumnIds, Children>>;
     };
-    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds>) => U)): U[];
-    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds>, value: U) => U, value: U): U;
+    map<U>(argument: string | ((itemResource: ItemResource<ItemTypeType, ColumnIds, Children>) => U)): U[];
+    reduce<U>(callback: (itemResource: ItemResource<ItemTypeType, ColumnIds, Children>, value: U) => U, value: U): U;
     /**
      * @description
      * Removes the reference to the {@link CollectionResource CollectionResource} from the {@link CollectionEntry CollectionEntry}

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

@@ -1,14 +1,19 @@
 import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { EntryParentNull, ExtractApiItemType, FieldMap, ItemEntry, ItemResourceFactory, PromiseInterface, ResponseColumnMap, TransactionCache } from '../internal';
-export declare class ItemResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> {
+import { CollectionResource, EntryParentNull, ExtractApiItemType, FieldMap, ItemEntry, ItemResourceFactory, PromiseInterface, ResponseColumnMap, TransactionCache } from '../internal';
+export declare type ChildCollectionResources = {
+    [ChildItemType in ApiEnumItemType]?: CollectionResource<ChildItemType>;
+};
+export declare type ChildCollectionResourcesNull = ChildCollectionResources | null;
+export declare class ItemResource<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull = any> {
     protected readonly factory: ItemResourceFactory;
     readonly entry: ItemEntry<ItemTypeType>;
-    protected readonly _isNew: boolean;
     protected readonly transaction: TransactionCache;
+    children: Children;
+    private readonly _isNew;
     columns: ResponseColumnMap<ItemTypeType, ColumnIds>;
     fields: FieldMap<ItemTypeType, ColumnIds>;
     initial: Readonly<FieldMap<ItemTypeType, ColumnIds>>;
-    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, _isNew: boolean, transaction: TransactionCache);
+    constructor(factory: ItemResourceFactory, entry: ItemEntry<ItemTypeType>, transaction: TransactionCache, children: Children, _isNew: boolean);
     onConstruct(): void;
     /**
      * @description

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

@@ -1,6 +1,6 @@
 import { ApiEnumApiType, ApiEnumApiTypeTsTypeMapping, ApiEnumItemType, ApiFields, ApiQuery as BackendApiQuery, ApiQueryConditionComparator as BackendTypesApiQueryConditionComparator, ApiQueryConditionComparatorShort as BackendApiQueryConditionComparatorShort, ApiQueryConditionCustom, ApiQueryConditionIn, ApiQueryConditionInShort, ApiQueryConditionLinkedTo, ApiQueryConditionSearch, ApiQueryConditionSubQuery, GetColumnType, ItemId } from '@rentman/backend-types';
 import moment from 'moment';
-import { ApiResponseProcessor, CollectionOptions, CollectionResource, ColumnSet, ItemEntry, ItemEntryOptionsInterface, ItemResource, RequestColumnExpansion } from '../internal';
+import { ApiResponseProcessor, ChildCollectionResourcesNull, CollectionOptions, CollectionResource, ColumnSet, ItemEntry, ItemEntryOptionsInterface, ItemResource, RequestColumnExpansion } from '../internal';
 export declare type ApiEnumApiTypeToTsTypeMap = {
     [ApiEnumApiType.TYPE_TOKEN]: string;
     [ApiEnumApiType.TYPE_ID]: number;
@@ -182,9 +182,6 @@ export interface FunctionChangesResolveSocketMessage extends SocketMessage {
         [key: string]: any;
     };
 }
-export declare type ItemResourceItemIdMap<T extends ItemResource = ItemResource> = {
-    [itemId: number]: T;
-};
 export declare type ItemResourcesItemTypeMap<T extends ItemResource = ItemResource> = {
     [itemType: string]: T[];
 };
@@ -193,6 +190,11 @@ export declare type ItemMap<T> = {
         [itemId: string]: T;
     };
 };
+export declare type ParentItemMap<T> = {
+    [parentId: number]: {
+        [itemType: string]: T;
+    };
+};
 export declare type ItemEntryMap<ItemTypeType extends ApiEnumItemType = any> = ItemMap<ItemEntry<ItemTypeType>>;
 export declare type ItemEntryParentIdMap<ItemTypeType extends ApiEnumItemType> = ParentIdMap<Array<ItemEntry<ItemTypeType>>>;
 export declare type ConversionMap = {
@@ -313,19 +315,17 @@ export declare type FieldChangeCallback<ItemTypeType extends ApiEnumItemType = a
 export declare type DeregFunction = () => void;
 export declare type OnChangeCallbackArgs<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = FieldChangeCallbackArgs<ItemTypeType, ColumnIds>;
 export declare type OnChangeCallback<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = FieldChangeCallback<ItemTypeType, ColumnIds>;
-export declare type OnAddCallbackArgs<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = {
-    itemResources: Array<ItemResource<ItemTypeType, ColumnIds>>;
-    collectionResource: CollectionResource<ItemTypeType, ColumnIds>;
+export declare type OnAddCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull> = (args: {
+    itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>;
+    collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>;
     isInitialCall: boolean;
     isCalledAfterSocketUpdate: boolean;
-};
-export declare type OnAddCallback<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = (args: OnAddCallbackArgs<ItemTypeType, ColumnIds>) => void;
-export declare type OnRemoveCallbackArgs<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = {
-    itemResources: Array<ItemResource<ItemTypeType, ColumnIds>>;
-    collectionResource: CollectionResource<ItemTypeType, ColumnIds>;
+}) => void;
+export declare type OnRemoveCallback<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]>, Children extends ChildCollectionResourcesNull> = (args: {
+    itemResources: Array<ItemResource<ItemTypeType, ColumnIds, Children>>;
+    collectionResource: CollectionResource<ItemTypeType, ColumnIds, Children>;
     isCalledAfterSocketUpdate: boolean;
-};
-export declare type OnRemoveCallback<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>> = (args: OnRemoveCallbackArgs<ItemTypeType, ColumnIds>) => void;
+}) => void;
 /************************************/
 export declare type ApiQueryConditionComparatorShort<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> = BackendApiQueryConditionComparatorShort<ItemTypeType, ColumnId> & {
     [_T in ColumnId]: 'NOW' | ApiEnumApiTypeTsTypeMapping[ExtractApiType<ApiFields[ItemTypeType][ColumnId]>];

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@rentman/rm-core",
-  "version": "8.1.9",
+  "version": "8.2.1",
   "description": "Rentman core functionalities",
   "main": "./dist/rm-core.js",
   "types": "./dist/types/index.d.ts",
   "dependencies": {
-    "@rentman/backend-types": "0.0.7",
+    "@rentman/backend-types": "*",
     "@babel/runtime": "^7.8.3"
   },
   "repository": {