@rentman/rm-core 2.0.7 → 2.0.9

package/dist/src/core.d.ts

@@ -1,49 +1,49 @@
-import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
-import { TemplateCache } from './classes/TemplateCache';
-import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
-import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
-import { ChangesProcessorFactory } from './factories/ChangesProcessorFactory';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from './interfaces';
-import { LinkTreeServiceInterface } from './interfaces/LinkTreeServiceInterface';
-export declare class RmCore {
-    version: string;
-    noop: typeof noop;
-    apiFormatter: ApiFormatter;
-    apiRequestService: ApiRequestService;
-    apiResponseProcessorFactory: ApiResponseProcessorFactory;
-    changesCompilationFactory: ChangesCompilationFactory;
-    changesProcessorFactory: ChangesProcessorFactory;
-    collectionCacheFactory: CollectionCacheFactory;
-    collectionEntryFactory: CollectionEntryFactory;
-    collectionEntryService: CollectionEntryService;
-    collectionMatcherFactory: CollectionMatcherFactory;
-    collectionResourceFactory: CollectionResourceFactory;
-    collectionResourceService: CollectionResourceService;
-    columnCache: ColumnCache;
-    columnExpansionFactory: ColumnExpansionFactory;
-    columnHandler: ColumnHandler;
-    columnInfoFactory: ColumnInfoFactory;
-    columnSetFactory: ColumnSetFactory;
-    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
-    columnUtil: ColumnUtil;
-    createRequestFactory: CreateRequestFactory;
-    itemCacheFactory: ItemCacheFactory;
-    itemEntryFactory: ItemEntryFactory;
-    itemEntryService: ItemEntryService;
-    itemResourceFactory: ItemResourceFactory;
-    keyService: KeyService;
-    transactionCacheFactory: TransactionCacheFactory;
-    lockService: LockService;
-    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
-    queryMatcherFactory: QueryMatcherFactory;
-    queryParserFactory: QueryParserFactory;
-    queryService: QueryService;
-    requestColumnExpansionFactory: RequestColumnExpansionFactory;
-    socketMessageHandler: SocketMessageHandler;
-    templateFactory: TemplateFactory;
-    changesDeltaFactory: ChangesDeltaFactory;
-    templateCache: TemplateCache;
-    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
-}
-export declare function noop(): void;
-export declare function identity(value: any): any;
+import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemEntryService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
+import { TemplateCache } from './classes/TemplateCache';
+import { ApiResponseProcessorFactory, ChangesCompilationFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, ColumnSubsetCacheFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory, TransactionCacheFactory } from './factories';
+import { ChangesDeltaFactory } from './factories/ChangesDeltaFactory';
+import { ChangesProcessorFactory } from './factories/ChangesProcessorFactory';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from './interfaces';
+import { LinkTreeServiceInterface } from './interfaces/LinkTreeServiceInterface';
+export declare class RmCore {
+    version: string;
+    noop: typeof noop;
+    apiFormatter: ApiFormatter;
+    apiRequestService: ApiRequestService;
+    apiResponseProcessorFactory: ApiResponseProcessorFactory;
+    changesCompilationFactory: ChangesCompilationFactory;
+    changesProcessorFactory: ChangesProcessorFactory;
+    collectionCacheFactory: CollectionCacheFactory;
+    collectionEntryFactory: CollectionEntryFactory;
+    collectionEntryService: CollectionEntryService;
+    collectionMatcherFactory: CollectionMatcherFactory;
+    collectionResourceFactory: CollectionResourceFactory;
+    collectionResourceService: CollectionResourceService;
+    columnCache: ColumnCache;
+    columnExpansionFactory: ColumnExpansionFactory;
+    columnHandler: ColumnHandler;
+    columnInfoFactory: ColumnInfoFactory;
+    columnSetFactory: ColumnSetFactory;
+    columnSubsetCacheFactory: ColumnSubsetCacheFactory;
+    columnUtil: ColumnUtil;
+    createRequestFactory: CreateRequestFactory;
+    itemCacheFactory: ItemCacheFactory;
+    itemEntryFactory: ItemEntryFactory;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    keyService: KeyService;
+    transactionCacheFactory: TransactionCacheFactory;
+    lockService: LockService;
+    moduleChangesCompilationFactory: ModuleChangesCompilationFactory;
+    queryMatcherFactory: QueryMatcherFactory;
+    queryParserFactory: QueryParserFactory;
+    queryService: QueryService;
+    requestColumnExpansionFactory: RequestColumnExpansionFactory;
+    socketMessageHandler: SocketMessageHandler;
+    templateFactory: TemplateFactory;
+    changesDeltaFactory: ChangesDeltaFactory;
+    templateCache: TemplateCache;
+    constructor(_apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseLibrary: PromiseLibraryInterface, linkTreeService: LinkTreeServiceInterface);
+}
+export declare function noop(): void;
+export declare function identity(value: any): any;

package/dist/src/factories/ApiResponseProcessorFactory.d.ts

@@ -1,6 +1,6 @@
-import { ApiFormatter, ApiResponseProcessor } from '../classes';
-export declare class ApiResponseProcessorFactory {
-    private apiFormatter;
-    constructor(apiFormatter: ApiFormatter);
-    construct(response: any): ApiResponseProcessor;
-}
+import { ApiFormatter, ApiResponseProcessor } from '../classes';
+export declare class ApiResponseProcessorFactory {
+    private apiFormatter;
+    constructor(apiFormatter: ApiFormatter);
+    construct(response: any): ApiResponseProcessor;
+}

package/dist/src/factories/ChangesCompilationFactory.d.ts

@@ -1,6 +1,6 @@
-import { ChangesCompilation } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-export declare class ChangesCompilationFactory {
-    constructor();
-    construct(transaction: TransactionCache): ChangesCompilation;
-}
+import { ChangesCompilation } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+export declare class ChangesCompilationFactory {
+    constructor();
+    construct(transaction: TransactionCache): ChangesCompilation;
+}

package/dist/src/factories/ChangesDeltaFactory.d.ts

@@ -1,9 +1,9 @@
-import { ItemEntryService } from '../classes';
-import { ChangesDelta } from '../classes/ChangesDelta';
-import { InternalChangesDelta } from '../classes/InternalChangesDelta';
-export declare class ChangesDeltaFactory {
-    private itemEntryService;
-    constructor(itemEntryService: ItemEntryService);
-    construct(): ChangesDelta;
-    constructInternalDelta(): InternalChangesDelta;
-}
+import { ItemEntryService } from '../classes';
+import { ChangesDelta } from '../classes/ChangesDelta';
+import { InternalChangesDelta } from '../classes/InternalChangesDelta';
+export declare class ChangesDeltaFactory {
+    private itemEntryService;
+    constructor(itemEntryService: ItemEntryService);
+    construct(): ChangesDelta;
+    constructInternalDelta(): InternalChangesDelta;
+}

package/dist/src/factories/ChangesProcessorFactory.d.ts

@@ -1,22 +1,22 @@
-import { ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ChangesCompilationFactory } from './ChangesCompilationFactory';
-import { ChangesDeltaFactory } from './ChangesDeltaFactory';
-import { ColumnExpansionFactory } from './ColumnExpansionFactory';
-import { CreateRequestFactory } from './CreateRequestFactory';
-import { RequestColumnExpansionFactory } from './RequestColumnExpansionFactory';
-export declare class ChangesProcessorFactory {
-    private changesDeltaFactory;
-    private apiRequestService;
-    private changesCompilationFactory;
-    private columnExpansionFactory;
-    private createRequestFactory;
-    private errorHandler;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    private collectionEntryService;
-    private itemEntryService;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService);
-    construct(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): ChangesProcessor;
-}
+import { ApiRequestService, ChangesProcessor, CollectionEntryService, ItemEntryService, OnAfterCreateCallback } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ChangesCompilationFactory } from './ChangesCompilationFactory';
+import { ChangesDeltaFactory } from './ChangesDeltaFactory';
+import { ColumnExpansionFactory } from './ColumnExpansionFactory';
+import { CreateRequestFactory } from './CreateRequestFactory';
+import { RequestColumnExpansionFactory } from './RequestColumnExpansionFactory';
+export declare class ChangesProcessorFactory {
+    private changesDeltaFactory;
+    private apiRequestService;
+    private changesCompilationFactory;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private collectionEntryService;
+    private itemEntryService;
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService);
+    construct(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): ChangesProcessor;
+}

package/dist/src/factories/CollectionCacheFactory.d.ts

@@ -1,8 +1,8 @@
-import { CollectionCache } from '../classes';
-import { AbstractCache } from '../classes/cache/AbstractCache';
-import { QueryMatcherFactory } from '../factories';
-export declare class CollectionCacheFactory {
-    private queryMatcherFactory;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(transaction: AbstractCache): CollectionCache;
-}
+import { CollectionCache } from '../classes';
+import { AbstractCache } from '../classes/cache/AbstractCache';
+import { QueryMatcherFactory } from '../factories';
+export declare class CollectionCacheFactory {
+    private queryMatcherFactory;
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    construct(transaction: AbstractCache): CollectionCache;
+}

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

@@ -1,11 +1,11 @@
-import { CollectionEntryService, KeyService } from '../classes';
-import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
-import { ItemType } from '../types/';
-import { ColumnSetFactory } from './ColumnSetFactory';
-export declare class CollectionEntryFactory {
-    private collectionEntryService;
-    private columnSetFactory;
-    private keyService;
-    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService);
-    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptionsInterface): CollectionEntry<ItemTypeType>;
-}
+import { CollectionEntryService, KeyService } from '../classes';
+import { CollectionEntry, CollectionEntryOptionsInterface } from '../models/';
+import { ItemType } from '../types/';
+import { ColumnSetFactory } from './ColumnSetFactory';
+export declare class CollectionEntryFactory {
+    private collectionEntryService;
+    private columnSetFactory;
+    private keyService;
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService);
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptionsInterface): CollectionEntry<ItemTypeType>;
+}

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

@@ -1,9 +1,9 @@
-import { CollectionMatcher, ServerCache, TransactionCache } from '../classes';
-import { QueryMatcherFactory } from '../factories';
-import { CollectionEntry } from '../models';
-import { ItemType } from '../types';
-export declare class CollectionMatcherFactory {
-    private queryMatcherFactory;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(transaction: TransactionCache | ServerCache, getCollectionEntries: <ItemTypeType extends ItemType>(itemType: ItemTypeType) => Array<CollectionEntry<ItemTypeType>>): CollectionMatcher;
-}
+import { CollectionMatcher, ServerCache, TransactionCache } from '../classes';
+import { QueryMatcherFactory } from '../factories';
+import { CollectionEntry } from '../models';
+import { ItemType } from '../types';
+export declare class CollectionMatcherFactory {
+    private queryMatcherFactory;
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    construct(transaction: TransactionCache | ServerCache, getCollectionEntries: <ItemTypeType extends ItemType>(itemType: ItemTypeType) => Array<CollectionEntry<ItemTypeType>>): CollectionMatcher;
+}

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

@@ -1,34 +1,34 @@
-import { KeyService } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
-import { ItemType } from '../types';
-import { ChangesDeltaFactory } from './ChangesDeltaFactory';
-export declare class CollectionResourceFactory {
-    errorHandler: ErrorHandlerInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    itemResourceFactory: ItemResourceFactory;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    changesDeltaFactory: ChangesDeltaFactory;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory);
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, transaction: TransactionCache): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-}
+import { KeyService } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ItemResourceFactory } from '../factories';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEditResource, CollectionEntry, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
+import { ItemType } from '../types';
+import { ChangesDeltaFactory } from './ChangesDeltaFactory';
+export declare class CollectionResourceFactory {
+    errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    itemResourceFactory: ItemResourceFactory;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    changesDeltaFactory: ChangesDeltaFactory;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, changesDeltaFactory: ChangesDeltaFactory);
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }, transaction: TransactionCache): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }, transaction: TransactionCache): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, transaction: TransactionCache): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+}

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

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

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

@@ -1,7 +1,7 @@
-import { ColumnInfo } from '../classes';
-import { ItemType, ResponseColumn, RootColumnMap } from '../types';
-export declare class ColumnInfoFactory {
-    constructor();
-    construct<ItemTypeType extends ItemType>(apiColumn: ResponseColumn, parent: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>;
-    constructFromRootMap<ItemTypeType extends ItemType>(rootColumnMap: RootColumnMap, parent?: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>[];
-}
+import { ColumnInfo } from '../classes';
+import { ItemType, ResponseColumn, RootColumnMap } from '../types';
+export declare class ColumnInfoFactory {
+    constructor();
+    construct<ItemTypeType extends ItemType>(apiColumn: ResponseColumn, parent: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>;
+    constructFromRootMap<ItemTypeType extends ItemType>(rootColumnMap: RootColumnMap, parent?: ColumnInfo<ItemTypeType> | null): ColumnInfo<ItemTypeType>[];
+}

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

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

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

@@ -1,6 +1,6 @@
-import { ColumnSubsetCache } from '../classes';
-import { ApiRequestColumns, ItemType } from '../types';
-export declare class ColumnSubsetCacheFactory {
-    constructor();
-    construct<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
-}
+import { ColumnSubsetCache } from '../classes';
+import { ApiRequestColumns, ItemType } from '../types';
+export declare class ColumnSubsetCacheFactory {
+    constructor();
+    construct<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns): ColumnSubsetCache<ItemTypeType>;
+}

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

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

package/dist/src/factories/ItemCacheFactory.d.ts

@@ -1,8 +1,8 @@
-import { ItemCache } from '../classes';
-import { AbstractCache } from '../classes/cache/AbstractCache';
-import { QueryMatcherFactory } from '../factories';
-export declare class ItemCacheFactory {
-    private queryMatcherFactory;
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    construct(transaction: AbstractCache): ItemCache;
-}
+import { ItemCache } from '../classes';
+import { AbstractCache } from '../classes/cache/AbstractCache';
+import { QueryMatcherFactory } from '../factories';
+export declare class ItemCacheFactory {
+    private queryMatcherFactory;
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    construct(transaction: AbstractCache): ItemCache;
+}

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

@@ -1,17 +1,17 @@
-import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
-import { ColumnSetFactory, ItemResourceFactory } from '../factories';
-import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ItemId, ItemType } from '../types';
-export declare class ItemEntryFactory {
-    authInterface: AuthInterface;
-    apiFormatter: ApiFormatter;
-    columnSetFactory: ColumnSetFactory;
-    exceptionHandler: ExceptionHandlerInterface;
-    itemEntryService: ItemEntryService;
-    itemResourceFactory: ItemResourceFactory;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    construct<ItemTypeType extends ItemType>(itemId: ItemId, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
-}
+import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
+import { ColumnSetFactory, ItemResourceFactory } from '../factories';
+import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry } from '../models';
+import { ItemId, ItemType } from '../types';
+export declare class ItemEntryFactory {
+    authInterface: AuthInterface;
+    apiFormatter: ApiFormatter;
+    columnSetFactory: ColumnSetFactory;
+    exceptionHandler: ExceptionHandlerInterface;
+    itemEntryService: ItemEntryService;
+    itemResourceFactory: ItemResourceFactory;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, exceptionHandler: ExceptionHandlerInterface, itemEntryService: ItemEntryService, itemResourceFactory: ItemResourceFactory, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    construct<ItemTypeType extends ItemType>(itemId: ItemId, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
+}

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

@@ -1,32 +1,32 @@
-import { ApiFormatter, ColumnUtil, LockService } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
-import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { ItemOptionsInterface, ItemType } from '../types';
-export declare type ResourceConstructor<ItemTypeType extends ItemType, T extends ItemResource<ItemTypeType>> = (itemEntry: ItemEntry<ItemTypeType>) => T;
-export declare class ItemResourceFactory {
-    apiFormatter: ApiFormatter;
-    lockService: LockService;
-    errorHandler: ErrorHandlerInterface;
-    promiseService: PromiseLibraryInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    columnUtil: ColumnUtil;
-    linkTreeService: LinkTreeServiceInterface;
-    constructor(apiFormatter: ApiFormatter, lockService: LockService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil, linkTreeService: LinkTreeServiceInterface);
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
-        edit: true;
-    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
-        remote: true;
-    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, transaction: TransactionCache): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        edit: true;
-    }, transaction: TransactionCache, isNew?: boolean): EditResource<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        remote: true;
-    }, transaction: TransactionCache, isNew?: boolean): LocalViewResource<ItemTypeType>;
-    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, transaction: TransactionCache, isNew?: boolean): RemoteViewResource<ItemTypeType>;
-    private constructWithOptions;
-}
+import { ApiFormatter, ColumnUtil, LockService } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
+import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
+import { ItemOptionsInterface, ItemType } from '../types';
+export declare type ResourceConstructor<ItemTypeType extends ItemType, T extends ItemResource<ItemTypeType>> = (itemEntry: ItemEntry<ItemTypeType>) => T;
+export declare class ItemResourceFactory {
+    apiFormatter: ApiFormatter;
+    lockService: LockService;
+    errorHandler: ErrorHandlerInterface;
+    promiseService: PromiseLibraryInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    columnUtil: ColumnUtil;
+    linkTreeService: LinkTreeServiceInterface;
+    constructor(apiFormatter: ApiFormatter, lockService: LockService, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, exceptionHandler: ExceptionHandlerInterface, columnUtil: ColumnUtil, linkTreeService: LinkTreeServiceInterface);
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
+        edit: true;
+    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
+        remote: true;
+    }, transaction: TransactionCache): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, transaction: TransactionCache): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        edit: true;
+    }, transaction: TransactionCache, isNew?: boolean): EditResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        remote: true;
+    }, transaction: TransactionCache, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, transaction: TransactionCache, isNew?: boolean): RemoteViewResource<ItemTypeType>;
+    private constructWithOptions;
+}

package/dist/src/factories/ModuleChangesCompilationFactory.d.ts

@@ -1,5 +1,5 @@
-import { ModuleChangesCompilation } from '../classes';
-import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
-export declare class ModuleChangesCompilationFactory {
-    construct(transaction: TransactionCache): ModuleChangesCompilation;
-}
+import { ModuleChangesCompilation } from '../classes';
+import { TransactionCache } from '../classes/cache/transaction/TransactionCache';
+export declare class ModuleChangesCompilationFactory {
+    construct(transaction: TransactionCache): ModuleChangesCompilation;
+}

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

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

package/dist/src/factories/QueryParserFactory.d.ts

@@ -1,6 +1,6 @@
-import { QueryParser } from '../classes';
-import { ApiQuery } from '../types';
-export declare class QueryParserFactory {
-    constructor();
-    construct(query: ApiQuery, parameters?: any): QueryParser;
-}
+import { QueryParser } from '../classes';
+import { ApiQuery } from '../types';
+export declare class QueryParserFactory {
+    constructor();
+    construct(query: ApiQuery, parameters?: any): QueryParser;
+}