@rentman/rm-core 8.1.7 → 8.1.8-dev1

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

@@ -1,3 +1,3 @@
-export interface ExceptionHandlerInterface {
-    (exception: any): void;
-}
+export interface ExceptionHandlerInterface {
+    (exception: any): void;
+}

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

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

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

@@ -1,25 +1,25 @@
-import { PromiseInterface } from '../types';
-export interface Deferred<T> {
-    resolve(value?: T | PromiseInterface<T>): void;
-    reject(reason?: any): void;
-    promise: PromiseInterface<T>;
-}
-export interface PromiseLibraryInterface {
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>, T10 | PromiseInterface<T10>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
-    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
-    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8]>;
-    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7]>;
-    all<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>]): PromiseInterface<[T1, T2, T3, T4, T5, T6]>;
-    all<T1, T2, T3, T4, T5>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>]): PromiseInterface<[T1, T2, T3, T4, T5]>;
-    all<T1, T2, T3, T4>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>]): PromiseInterface<[T1, T2, T3, T4]>;
-    all<T1, T2, T3>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>]): PromiseInterface<[T1, T2, T3]>;
-    all<T1, T2>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>]): PromiseInterface<[T1, T2]>;
-    all<TAll>(promises: Array<TAll | PromiseInterface<TAll>>): PromiseInterface<TAll[]>;
-    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
-    all<T>(promises: {
-        [K in keyof T]: (PromiseInterface<T[K]> | T[K] | null);
-    }): PromiseInterface<T>;
-    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
-    reject(value?: any): PromiseInterface<any>;
-    defer<T>(): Deferred<T>;
-}
+import { PromiseInterface } from '../internal';
+export interface Deferred<T> {
+    resolve(value?: T | PromiseInterface<T>): void;
+    reject(reason?: any): void;
+    promise: PromiseInterface<T>;
+}
+export interface PromiseLibraryInterface {
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>, T10 | PromiseInterface<T10>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>, T9 | PromiseInterface<T9>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+    all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>, T8 | PromiseInterface<T8>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+    all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>, T7 | PromiseInterface<T7>]): PromiseInterface<[T1, T2, T3, T4, T5, T6, T7]>;
+    all<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>, T6 | PromiseInterface<T6>]): PromiseInterface<[T1, T2, T3, T4, T5, T6]>;
+    all<T1, T2, T3, T4, T5>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>, T5 | PromiseInterface<T5>]): PromiseInterface<[T1, T2, T3, T4, T5]>;
+    all<T1, T2, T3, T4>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>, T4 | PromiseInterface<T4>]): PromiseInterface<[T1, T2, T3, T4]>;
+    all<T1, T2, T3>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>, T3 | PromiseInterface<T3>]): PromiseInterface<[T1, T2, T3]>;
+    all<T1, T2>(values: [T1 | PromiseInterface<T1>, T2 | PromiseInterface<T2>]): PromiseInterface<[T1, T2]>;
+    all<TAll>(promises: Array<TAll | PromiseInterface<TAll>>): PromiseInterface<TAll[]>;
+    all(iterable: Array<PromiseInterface<any> | any>): PromiseInterface<any[]>;
+    all<T>(promises: {
+        [K in keyof T]: (PromiseInterface<T[K]> | T[K] | null);
+    }): PromiseInterface<T>;
+    when<T>(value?: PromiseInterface<T> | T): PromiseInterface<T>;
+    reject(value?: any): PromiseInterface<any>;
+    defer<T>(): Deferred<T>;
+}

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

@@ -1,7 +1,5 @@
-import { ItemCreateService } from '../classes';
-import { ChangesProcessorFactory } from '../factories';
-import { AbstractCacheDependencyInterface } from './AbstractCacheDependencyInterface';
-export interface ServerCacheDependencyInterface extends AbstractCacheDependencyInterface {
-    changesProcessorFactory: ChangesProcessorFactory;
-    itemCreateService: ItemCreateService;
-}
+import { AbstractCacheDependencyInterface, ChangesProcessorFactory, ItemCreateService } from '../internal';
+export interface ServerCacheDependencyInterface extends AbstractCacheDependencyInterface {
+    changesProcessorFactory: ChangesProcessorFactory;
+    itemCreateService: ItemCreateService;
+}

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

@@ -1,3 +1,3 @@
-export interface SocketMessageInterface {
-    on(event: string, messageHandler: (message: any) => void): () => boolean;
-}
+export interface SocketMessageInterface {
+    on(event: string, messageHandler: (message: any) => void): () => boolean;
+}

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

@@ -1,21 +1,17 @@
-import { CollectionEntryService, ColumnCache, ColumnHandler, ColumnUtil, KeyService, QueryService } from '../classes';
-import { ChangesDeltaFactory, CollectionMatcherFactory, ColumnExpansionFactory, ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../factories';
-import { ErrorHandlerInterface } from './ErrorHandlerInterface';
-import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
-import { PromiseLibraryInterface } from './PromiseLibraryInterface';
-export interface TransactionCollectionHandlerDependencyInterface {
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    columnUtil: ColumnUtil;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    columnExpansionFactory: ColumnExpansionFactory;
-    changesDeltaFactory: ChangesDeltaFactory;
-    collectionEntryService: CollectionEntryService;
-    collectionMatcherFactory: CollectionMatcherFactory;
-    columnHandler: ColumnHandler;
-    errorHandler: ErrorHandlerInterface;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    queryService: QueryService;
-    columnCache: ColumnCache;
-}
+import { CacheSyncerFactory, ChangesDeltaFactory, CollectionEntryService, ColumnCache, ColumnExpansionFactory, ColumnHandler, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, ExceptionHandlerInterface, KeyService, PromiseLibraryInterface, QueryService, RequestColumnExpansionFactory } from '../internal';
+export interface TransactionCollectionHandlerDependencyInterface {
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    columnUtil: ColumnUtil;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnExpansionFactory: ColumnExpansionFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
+    collectionEntryService: CollectionEntryService;
+    collectionMatcherFactory: CacheSyncerFactory;
+    columnHandler: ColumnHandler;
+    errorHandler: ErrorHandlerInterface;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    queryService: QueryService;
+    columnCache: ColumnCache;
+}

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

@@ -1,27 +1,22 @@
-import { ApiFormatter, CollectionEntryService, ColumnHandler, ColumnUtil, ConversionMapService, ItemCreateService, ItemEntryService, KeyService } from '../classes';
-import { TemplateCache } from '../classes/TemplateCache';
-import { ChangesDeltaFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
-import { ErrorHandlerInterface } from './ErrorHandlerInterface';
-import { ExceptionHandlerInterface } from './ExceptionHandlerInterface';
-import { PromiseLibraryInterface } from './PromiseLibraryInterface';
-export interface TransactionItemHandlerDependencyInterface {
-    apiFormatter: ApiFormatter;
-    changesDeltaFactory: ChangesDeltaFactory;
-    columnExpansionFactory: ColumnExpansionFactory;
-    columnHandler: ColumnHandler;
-    columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    columnUtil: ColumnUtil;
-    conversionMapService: ConversionMapService;
-    errorHandler: ErrorHandlerInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    itemCacheFactory: ItemCacheFactory;
-    itemCreateService: ItemCreateService;
-    itemEntryFactory: ItemEntryFactory;
-    itemEntryService: ItemEntryService;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    templateCache: TemplateCache;
-    collectionEntryService: CollectionEntryService;
-}
+import { ApiFormatter, ChangesDeltaFactory, CollectionEntryService, ColumnExpansionFactory, ColumnHandler, ColumnSetFactory, ColumnSubsetCacheFactory, ColumnUtil, ConversionMapService, ErrorHandlerInterface, ExceptionHandlerInterface, ItemCacheFactory, ItemCreateService, ItemEntryFactory, ItemEntryService, KeyService, PromiseLibraryInterface, RequestColumnExpansionFactory, TemplateCache } from '../internal';
+export interface TransactionItemHandlerDependencyInterface {
+    apiFormatter: ApiFormatter;
+    changesDeltaFactory: ChangesDeltaFactory;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnUtil: ColumnUtil;
+    conversionMapService: ConversionMapService;
+    errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    itemCacheFactory: ItemCacheFactory;
+    itemCreateService: ItemCreateService;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    templateCache: TemplateCache;
+    collectionEntryService: CollectionEntryService;
+}

package/dist/types/internal.d.ts

@@ -0,0 +1,104 @@
+/**
+ * This is the only place where things should be exported. *All files* should import from this file.
+ * Exports here should be ordered by inheritance.
+ */
+export * from './constants';
+export * from './types/ItemTypesCollection';
+export * from './types/PromiseInterface';
+export * from './models/ItemEntryOptions';
+export * from './models/ItemEntry';
+export * from './models/ItemResource';
+export * from './models/CachedQueryItem';
+export * from './models/CollectionOptions';
+export * from './models/CollectionEntry';
+export * from './models/CollectionResource';
+export * from './models/Template';
+export * from './interfaces/PromiseLibraryInterface';
+export * from './interfaces/ErrorHandlerInterface';
+export * from './interfaces/ExceptionHandlerInterface';
+export * from './interfaces/AuthInterface';
+export * from './interfaces/ApiRequestServiceInterface';
+export * from './interfaces/SocketMessageInterface';
+export * from './interfaces/LinkTreeServiceInterface';
+export * from './classes/Util';
+export * from './classes/ApiFormatter';
+export * from './classes/ApiRequestService';
+export * from './classes/ApiResponseProcessor';
+export * from './classes/ChangesCompilation';
+export * from './classes/ChangesProcessor';
+export * from './classes/CollectionEntryService';
+export * from './classes/CacheSyncer';
+export * from './classes/CollectionResourceService';
+export * from './classes/ColumnCache';
+export * from './classes/ColumnExpansion';
+export * from './classes/ColumnHandler';
+export * from './classes/ColumnInfo';
+export * from './classes/ColumnSet';
+export * from './classes/ColumnSubsetCache';
+export * from './classes/ColumnUtil';
+export * from './classes/ConversionMapService';
+export * from './classes/CreateRequest';
+export * from './classes/ItemCache';
+export * from './classes/ItemEntryService';
+export * from './classes/KeyService';
+export * from './classes/cache/transaction/TransactionEventHandler';
+export * from './classes/LockService';
+export * from './classes/ModuleChangesCompilation';
+export * from './classes/QueryMatcher';
+export * from './classes/QueryParserBase';
+export * from './classes/QueryColumnExtractor';
+export * from './classes/QueryContainsLocalIdParser';
+export * from './classes/QueryLinkedToParser';
+export * from './classes/QueryLocallyMatchableParser';
+export * from './classes/QueryParser';
+export * from './classes/QueryParserIdUpdater';
+export * from './classes/QueryService';
+export * from './classes/RequestColumnExpansion';
+export * from './classes/SocketMessageHandler';
+export * from './classes/cache/AbstractCache';
+export * from './classes/cache/server/ServerCache';
+export * from './classes/cache/ItemHandlerBase';
+export * from './classes/cache/server/ServerItemHandler';
+export * from './classes/cache/CachedQueryHandlerBase';
+export * from './classes/cache/server/ServerCachedQueryHandler';
+export * from './classes/cache/transaction/TransactionCache';
+export * from './classes/cache/transaction/TransactionItemHandler';
+export * from './classes/cache/transaction/TransactionCachedQueryHandler';
+export * from './classes/cache/transaction/TransactionCollectionHandler';
+export * from './classes/cache/transaction/TransactionEventHandler';
+export * from './classes/cache/transaction/TransactionValidator';
+export * from './classes/ChangesDeltaBase';
+export * from './classes/ChangesDelta';
+export * from './classes/InternalChangesDelta';
+export * from './classes/ParentChangesDelta';
+export * from './classes/RequestBufferManager';
+export * from './classes/RequestBuffer';
+export * from './classes/ItemCreateService';
+export * from './classes/CreatedChangesDelta';
+export * from './classes/TemplateCache';
+export * from './factories/ApiResponseProcessorFactory';
+export * from './factories/ChangesCompilationFactory';
+export * from './factories/CollectionEntryFactory';
+export * from './factories/CacheSyncerFactory';
+export * from './factories/CollectionResourceFactory';
+export * from './factories/ColumnExpansionFactory';
+export * from './factories/ColumnInfoFactory';
+export * from './factories/ColumnSetFactory';
+export * from './factories/ColumnSubsetCacheFactory';
+export * from './factories/CreateRequestFactory';
+export * from './factories/ItemCacheFactory';
+export * from './factories/ItemEntryFactory';
+export * from './factories/ItemResourceFactory';
+export * from './factories/TransactionCacheFactory';
+export * from './factories/ModuleChangesCompilationFactory';
+export * from './factories/QueryMatcherFactory';
+export * from './factories/QueryParserFactory';
+export * from './factories/RequestColumnExpansionFactory';
+export * from './factories/TemplateFactory';
+export * from './factories/ChangesDeltaFactory';
+export * from './factories/ChangesProcessorFactory';
+export * from './interfaces/AbstractCacheDependencyInterface';
+export * from './interfaces/TransactionItemHandlerDependencyInterface';
+export * from './interfaces/TransactionCollectionHandlerDependencyInterface';
+export * from './interfaces/ServerCacheDependencyInterface';
+export * from './core';

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

@@ -0,0 +1,19 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiRequestColumns, CollectionQuery, ItemEntry, PromiseInterface, PromiseLibraryInterface } from '../internal';
+export declare class CachedQueryItem<ItemTypeType extends ApiEnumItemType = any> {
+    readonly itemType: ItemTypeType;
+    query: CollectionQuery;
+    items: ItemEntry<ItemTypeType>[];
+    requestColumns: ApiRequestColumns;
+    private promiseService;
+    promise: PromiseInterface<this>;
+    private deferred;
+    constructor(itemType: ItemTypeType, query: CollectionQuery, items: ItemEntry<ItemTypeType>[], requestColumns: ApiRequestColumns, promiseService: PromiseLibraryInterface);
+    itemsResolved(): boolean;
+    /**
+     * Resolve can be called on items that are already resolved. The request buffer might or might not combine
+     * requests together.
+     */
+    resolve(): void;
+    reject(reason: any): void;
+}

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

@@ -1,24 +1,21 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { CollectionEntryService, ColumnCache, ColumnExpansion, ColumnSet, KeyService, QueryService } from '../classes';
-import { ColumnSetFactory } from '../factories';
-import { CollectionQuery, EntryParentNull, PromiseInterface } from '../types';
-import { CollectionOptions } from './CollectionOptions';
-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, 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, ColumnIds>);
-    isLocal(): boolean;
-    queueReload(): void;
-    expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
-}
+import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
+import { CollectionEntryService, CollectionOptions, CollectionQuery, ColumnCache, ColumnExpansion, ColumnSet, ColumnSetFactory, EntryParentNull, KeyService, PromiseInterface, QueryService } from '../internal';
+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, 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, ColumnIds>);
+    isLocal(): boolean;
+    queueReload(): void;
+    expandColumns(columnExpansion: ColumnExpansion<ItemTypeType>): void;
+}

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

@@ -1,24 +1,42 @@
-import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
-import { CollectionResource, ItemResource } from '../models';
-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, ColumnIds>;
-    onRemove: CollectionResourceCallback<ItemTypeType, ColumnIds>;
-    onChange: FieldChangeCallback;
-    custom: any;
-    callOnAddWithInitialItems: boolean;
-    /**
-     * @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>);
-}
+import { ApiEnumItemType, ApiFields } from '@rentman/backend-types';
+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: 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(optionsInterface: CollectionOptionsInterface<ItemTypeType, ColumnIds>);
+}

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

@@ -1,78 +1,87 @@
-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, 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, ColumnIds>;
-    transaction: TransactionCache;
-    entry: CollectionEntry<ItemTypeType, ColumnIds>;
-    columns: ResponseColumnItemTypeMap;
-    items: Array<ItemResource<ItemTypeType, ColumnIds>>;
-    protected itemIdMap: ItemResourceItemIdMap<ItemResource<ItemTypeType, ColumnIds>>;
-    private fieldChangeDeregFns;
-    private readonly onChangeCallbacks;
-    private readonly onAddCallbacks;
-    private readonly onRemoveCallbacks;
-    /**
-     * @description
-     * 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>>);
-    onConstruct(): void;
-    /**
-     * @description
-     * Removes the query (if it's cached) from the TransactionCachedQueryHandler and redoes the query
-     */
-    refresh(): PromiseInterface<void>;
-    setLimit(newLimit: number | ApiRequestLimit): void;
-    onAdd(callback: OnAddCallback<ItemTypeType, ColumnIds>): DeregFunction;
-    onChange(callback: OnChangeCallback<ItemTypeType, ColumnIds>): DeregFunction;
-    onRemove(callback: OnRemoveCallback<ItemTypeType, ColumnIds>): DeregFunction;
-    __clear(): void;
-    /**
-     * @deprecated
-     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
-     */
-    moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
-    removeItems(idArray: ItemId[]): PromiseInterface<ChangesDeltaResult>;
-    removeItem(itemId: ItemId): PromiseInterface<ChangesDeltaResult>;
-    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>>;
-    /**
-     * @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;
-    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, 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}
-     *
-     * @remarks
-     * - Doesn't revert changes on the items themselves
-     */
-    clearResource(): void;
-    private registerListeners;
-    private __registerCallback;
-    private limitAfterRemove;
-    private limitAfterAdd;
-}
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
+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, Children>>;
+    protected itemIdMap: {
+        [itemId: number]: ItemResource<ItemTypeType, ColumnIds, Children>;
+    };
+    private fieldChangeDeregFns;
+    private readonly onChangeCallbacks;
+    private readonly onAddCallbacks;
+    private readonly onRemoveCallbacks;
+    /**
+     * @description
+     * 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>>, childCollectionResourceMap: Children);
+    onConstruct(): void;
+    /**
+     * @description
+     * Removes the query (if it's cached) from the TransactionCachedQueryHandler and redoes the query
+     */
+    refresh(): PromiseInterface<void>;
+    setLimit(newLimit: number | ApiRequestLimit): void;
+    onAdd(callback: OnAddCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
+    onChange(callback: OnChangeCallback<ItemTypeType, ColumnIds>): DeregFunction;
+    onRemove(callback: OnRemoveCallback<ItemTypeType, ColumnIds, Children>): DeregFunction;
+    __clear(): void;
+    /**
+     * @deprecated
+     * Use {@link ChangesDelta.setItemMoved ChangesDelta.setItemMoved}
+     */
+    moveItems(itemEntries: Array<ItemEntry<ItemTypeType>>, destinationResource: CollectionResource<ItemTypeType>): void;
+    removeItems(idArray: ItemId[]): PromiseInterface<ChangesDeltaResult>;
+    removeItem(itemId: ItemId): PromiseInterface<ChangesDeltaResult>;
+    addItems(valuesArray: Array<Partial<FieldMap<ItemTypeType, ColumnIds>>>): PromiseInterface<ChangesDeltaResult>;
+    addItem(values: Partial<FieldMap<ItemTypeType>>): PromiseInterface<ChangesDeltaResult>;
+    getIdArray(): ItemId[];
+    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, 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, 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, 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}
+     *
+     * @remarks
+     * - Doesn't revert changes on the items themselves
+     */
+    clearResource(): void;
+    private registerListeners;
+    private __registerCallback;
+    private limitAfterRemove;
+    private limitAfterAdd;
+}