@rentman/rm-core 1.7.1 → 1.7.3

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

@@ -1,32 +1,33 @@
-import { ChangesProcessor, KeyService, LocalCache, ResourceCache } from '../classes';
-import { ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
-export declare class CollectionResourceFactory {
-    errorHandler: ErrorHandlerInterface;
-    exceptionHandler: ExceptionHandlerInterface;
-    itemResourceFactory: ItemResourceFactory;
-    changesProcessor: ChangesProcessor;
-    keyService: KeyService;
-    promiseService: PromiseLibraryInterface;
-    readonly cache: ResourceCache<CollectionResource>;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessor: ChangesProcessor, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
-        editItems: true;
-        editCollection: true;
-    }, level: number, localCache: LocalCache | null): CollectionEditResource<EditResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
-        remoteItems: true;
-        editCollection: true;
-    }, level: number, localCache: LocalCache | null): CollectionEditResource<RemoteViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
-        editCollection: true;
-    }, level: number, localCache: LocalCache | null): CollectionEditResource<LocalViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
-        editItems: true;
-    }, level: number, localCache: LocalCache | null): CollectionViewResource<EditResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface & {
-        remoteItems: true;
-    }, level: number, localCache: LocalCache | null): CollectionViewResource<RemoteViewResource>;
-    construct(collectionEntry: CollectionEntry, options: CollectionResourceOptionsInterface, level: number, localCache: LocalCache | null): CollectionViewResource<LocalViewResource>;
-}
+import { ChangesProcessor, KeyService, LocalCache, ResourceCache } from '../classes';
+import { ItemResourceFactory } from '../factories';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, LocalViewResource, RemoteViewResource } from '../models';
+import { ItemType } from '../types';
+export declare class CollectionResourceFactory {
+    errorHandler: ErrorHandlerInterface;
+    exceptionHandler: ExceptionHandlerInterface;
+    itemResourceFactory: ItemResourceFactory;
+    changesProcessor: ChangesProcessor;
+    keyService: KeyService;
+    promiseService: PromiseLibraryInterface;
+    readonly cache: ResourceCache<CollectionResource<any>>;
+    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessor: ChangesProcessor, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+        editCollection: true;
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+        editCollection: true;
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editCollection: true;
+    }, level: number, localCache: LocalCache | null): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        editItems: true;
+    }, level: number, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
+        remoteItems: true;
+    }, level: number, localCache: LocalCache | null): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>, level: number, localCache: LocalCache | null): 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, ResponseColumnMap } from '../types';
-export declare class ColumnExpansionFactory {
-    private columnInfoFactory;
-    constructor(columnInfoFactory: ColumnInfoFactory);
-    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ColumnExpansion;
-}
+import { ColumnExpansion } from '../classes';
+import { ColumnInfoFactory } from '../factories';
+import { ApiRequestColumns, ItemType, ResponseColumnMap } from '../types';
+export declare class ColumnExpansionFactory {
+    private columnInfoFactory;
+    constructor(columnInfoFactory: ColumnInfoFactory);
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ColumnExpansion<ItemTypeType>;
+}

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

@@ -1,7 +1,7 @@
-import { ColumnInfo } from '../classes';
-import { ResponseColumn, RootColumnMap } from '../types';
-export declare class ColumnInfoFactory {
-    constructor();
-    construct(apiColumn: ResponseColumn, parent: ColumnInfo | null): ColumnInfo;
-    constructFromRootMap(rootColumnMap: RootColumnMap, parent?: ColumnInfo | null): ColumnInfo[];
-}
+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,11 +1,11 @@
-import { ColumnHandler, ColumnSet, ColumnUtil } from '../classes';
-import { ColumnInfoFactory } from '../factories';
-import { ApiRequestColumns, ItemType, ResponseColumnMap } from '../types';
-export declare class ColumnSetFactory {
-    private columnHandler;
-    private columnUtil;
-    private columnInfoFactory;
-    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory);
-    constructStub(itemType: ItemType, requestColumns: ApiRequestColumns): ColumnSet;
-    construct(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet;
-}
+import { ColumnHandler, ColumnSet, ColumnUtil } from '../classes';
+import { ColumnInfoFactory } from '../factories';
+import { ApiRequestColumns, ItemType, ResponseColumnMap } 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>;
+    construct<ItemTypeType extends ItemType>(itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): ColumnSet<ItemTypeType>;
+}

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

@@ -1,6 +1,6 @@
-import { ColumnSubsetCache } from '../classes';
-import { ApiRequestColumns } from '../types';
-export declare class ColumnSubsetCacheFactory {
-    constructor();
-    construct(requestColumns: ApiRequestColumns): ColumnSubsetCache;
-}
+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 { CollectionCache, CollectionHandler, CreateCompilation, CreateRequest, KeyService } from '../classes';
-import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestParameterMap } from '../types';
-export declare class CreateRequestFactory {
-    private collectionHandler;
-    private collectionMatcherFactory;
-    private keyService;
-    private requestColumnExpansionFactory;
-    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory);
-    construct(compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean): CreateRequest;
-}
+import { CollectionCache, CollectionHandler, CreateCompilation, CreateRequest, KeyService } from '../classes';
+import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
+import { CreateRequestParameterMap, ItemType } from '../types';
+export declare class CreateRequestFactory {
+    private collectionHandler;
+    private collectionMatcherFactory;
+    private keyService;
+    private requestColumnExpansionFactory;
+    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    construct<ItemTypeType extends ItemType>(compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean): CreateRequest<ItemTypeType>;
+}

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

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

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

@@ -1,21 +1,21 @@
-import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
-import { ColumnSetFactory, ItemResourceFactory } from '../factories';
-import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry, Template } from '../models';
-import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, 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);
-    constructStub(itemType: ItemType, itemId: ItemId, columnSetStub: ColumnSet): ItemEntry;
-    constructLocalLinked(itemType: ItemType, itemId: ItemId, initial: FieldMap, parent: EntryParentNull, columnSet: ColumnSet, conversionMap: ItemIdConversionMap): ItemEntry;
-    constructLocal(itemId: ItemId, template: Template, modified: FieldMap, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet, conversionMap?: ItemIdConversionMap): ItemEntry;
-    constructDeferred(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry;
-    construct(itemId: ItemId, initial: FieldMap, derived: FieldMap, columnInfo: ColumnSet): ItemEntry;
-}
+import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
+import { ColumnSetFactory, ItemResourceFactory } from '../factories';
+import { AuthInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry, Template } from '../models';
+import { ApiRequestColumns, EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, 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);
+    constructStub<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, columnSetStub: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
+    constructLocalLinked<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, initial: FieldMap<ItemTypeType>, parent: EntryParentNull, columnSet: ColumnSet<ItemTypeType>, conversionMap: ItemIdConversionMap): ItemEntry<ItemTypeType>;
+    constructLocal<ItemTypeType extends ItemType>(itemId: ItemId, template: Template<ItemTypeType>, modified: FieldMap<ItemTypeType>, derived: FieldMap, parent?: EntryParentNull, columnSet?: ColumnSet<ItemTypeType>, conversionMap?: ItemIdConversionMap): ItemEntry<ItemTypeType>;
+    constructDeferred<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, requestColumns: ApiRequestColumns, deferRequest: boolean): ItemEntry<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemId: ItemId, initial: FieldMap<ItemTypeType>, derived: FieldMap, columnInfo: ColumnSet<ItemTypeType>): ItemEntry<ItemTypeType>;
+}

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

@@ -1,29 +1,29 @@
-import { ApiFormatter, ChangesProcessor, LocalCache, LockService, ResourceCache } from '../classes';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { ItemOptionsInterface } from '../types';
-export declare type ResourceConstructor<T extends ItemResource> = (itemEntry: ItemEntry) => T;
-export declare class ItemResourceFactory {
-    apiFormatter: ApiFormatter;
-    lockService: LockService;
-    changesProcessor: ChangesProcessor;
-    errorHandler: ErrorHandlerInterface;
-    promiseService: PromiseLibraryInterface;
-    readonly cache: ResourceCache<ItemResource>;
-    constructor(apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
-    getConstructor(options: ItemOptionsInterface & {
-        edit: true;
-    }, level: number, localCache: LocalCache | null): ResourceConstructor<EditResource>;
-    getConstructor(options: ItemOptionsInterface & {
-        remote: true;
-    }, level: number, localCache: LocalCache | null): ResourceConstructor<RemoteViewResource>;
-    getConstructor(options: ItemOptionsInterface, level: number, localCache: LocalCache | null): ResourceConstructor<LocalViewResource>;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
-        edit: true;
-    }, level: number, localCache?: LocalCache | null, isNew?: boolean): EditResource;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface & {
-        remote: true;
-    }, level: number, localCache?: LocalCache | null, isNew?: boolean): LocalViewResource;
-    construct(itemEntry: ItemEntry, options: ItemOptionsInterface, level: number, localCache?: LocalCache | null, isNew?: boolean): RemoteViewResource;
-    private constructWithOptions;
-}
+import { ApiFormatter, ChangesProcessor, LocalCache, LockService, ResourceCache } from '../classes';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+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;
+    changesProcessor: ChangesProcessor;
+    errorHandler: ErrorHandlerInterface;
+    promiseService: PromiseLibraryInterface;
+    readonly cache: ResourceCache<ItemResource<any>>;
+    constructor(apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
+        edit: true;
+    }, level: number, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, EditResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface & {
+        remote: true;
+    }, level: number, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, RemoteViewResource<ItemTypeType>>;
+    getConstructor<ItemTypeType extends ItemType>(options: ItemOptionsInterface, level: number, localCache: LocalCache | null): ResourceConstructor<ItemTypeType, LocalViewResource<ItemTypeType>>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        edit: true;
+    }, level: number, localCache?: LocalCache | null, isNew?: boolean): EditResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
+        remote: true;
+    }, level: number, localCache?: LocalCache | null, isNew?: boolean): LocalViewResource<ItemTypeType>;
+    construct<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, level: number, localCache?: LocalCache | null, isNew?: boolean): RemoteViewResource<ItemTypeType>;
+    private constructWithOptions;
+}

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

@@ -1,16 +1,16 @@
-import { ChangesProcessor, LocalCache, LockService } from '../classes';
-import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-export declare class LocalCacheFactory {
-    private changesProcessor;
-    private collectionCacheFactory;
-    private collectionResourceFactory;
-    private errorHandler;
-    private exceptionHandler;
-    private itemCacheFactory;
-    private itemResourceFactory;
-    private lockService;
-    private promiseService;
-    constructor(changesProcessor: ChangesProcessor, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface);
-    construct(id: string, defaultResourceLevel: number): LocalCache;
-}
+import { ChangesProcessor, LocalCache, LockService } from '../classes';
+import { CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+export declare class LocalCacheFactory {
+    private changesProcessor;
+    private collectionCacheFactory;
+    private collectionResourceFactory;
+    private errorHandler;
+    private exceptionHandler;
+    private itemCacheFactory;
+    private itemResourceFactory;
+    private lockService;
+    private promiseService;
+    constructor(changesProcessor: ChangesProcessor, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface);
+    construct(id: string, defaultResourceLevel: number): LocalCache;
+}

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

@@ -1,5 +1,6 @@
-import { CollectionCache, ItemCache, ModuleChangesCompilation } from '../classes';
-import { ItemEntry } from '../models';
-export declare class ModuleChangesCompilationFactory {
-    construct(rootItem: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache): ModuleChangesCompilation;
-}
+import { CollectionCache, ItemCache, ModuleChangesCompilation } from '../classes';
+import { ItemEntry } from '../models';
+import { ItemType } from '../types';
+export declare class ModuleChangesCompilationFactory {
+    construct<ItemTypeType extends ItemType>(rootItem: ItemEntry<ItemTypeType>, singleItemCache: ItemCache, collectionCache: CollectionCache): ModuleChangesCompilation<ItemTypeType>;
+}

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;
+}

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

@@ -1,6 +1,6 @@
-import { ColumnUtil, RequestColumnExpansion } from '../classes';
-export declare class RequestColumnExpansionFactory {
-    private columnUtil;
-    constructor(columnUtil: ColumnUtil);
-    construct(): RequestColumnExpansion;
-}
+import { ColumnUtil, RequestColumnExpansion } from '../classes';
+export declare class RequestColumnExpansionFactory {
+    private columnUtil;
+    constructor(columnUtil: ColumnUtil);
+    construct(): RequestColumnExpansion;
+}

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

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

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

@@ -1,21 +1,21 @@
-export * from './ApiResponseProcessorFactory';
-export * from './BatchStatusFactory';
-export * from './ChangesCompilationFactory';
-export * from './CollectionCacheFactory';
-export * from './CollectionEntryFactory';
-export * from './CollectionMatcherFactory';
-export * from './CollectionResourceFactory';
-export * from './ColumnExpansionFactory';
-export * from './ColumnInfoFactory';
-export * from './ColumnSetFactory';
-export * from './ColumnSubsetCacheFactory';
-export * from './CreateRequestFactory';
-export * from './ItemCacheFactory';
-export * from './ItemEntryFactory';
-export * from './ItemResourceFactory';
-export * from './LocalCacheFactory';
-export * from './ModuleChangesCompilationFactory';
-export * from './QueryMatcherFactory';
-export * from './QueryParserFactory';
-export * from './RequestColumnExpansionFactory';
-export * from './TemplateFactory';
+export * from './ApiResponseProcessorFactory';
+export * from './BatchStatusFactory';
+export * from './ChangesCompilationFactory';
+export * from './CollectionCacheFactory';
+export * from './CollectionEntryFactory';
+export * from './CollectionMatcherFactory';
+export * from './CollectionResourceFactory';
+export * from './ColumnExpansionFactory';
+export * from './ColumnInfoFactory';
+export * from './ColumnSetFactory';
+export * from './ColumnSubsetCacheFactory';
+export * from './CreateRequestFactory';
+export * from './ItemCacheFactory';
+export * from './ItemEntryFactory';
+export * from './ItemResourceFactory';
+export * from './LocalCacheFactory';
+export * from './ModuleChangesCompilationFactory';
+export * from './QueryMatcherFactory';
+export * from './QueryParserFactory';
+export * from './RequestColumnExpansionFactory';
+export * from './TemplateFactory';

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
-export * from './core';
-export * from './constants';
-export * from './models';
-export * from './interfaces';
-export * from './classes';
-export * from './factories';
-export * from './types';
+export * from './core';
+export * from './constants';
+export * from './models';
+export * from './interfaces';
+export * from './classes';
+export * from './factories';
+export * from './types';

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

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

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

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

package/dist/src/interfaces/ErrorHandlerInterface.d.ts

@@ -1,5 +1,5 @@
-import { PromiseInterface } from '../types';
-export interface ErrorHandlerInterface {
-    reject(error?: object): PromiseInterface<any>;
-    notifyError(error?: any): PromiseInterface<any>;
-}
+import { PromiseInterface } from '../types';
+export interface ErrorHandlerInterface {
+    reject(error?: object): PromiseInterface<any>;
+    notifyError(error?: any): PromiseInterface<any>;
+}

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

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

package/dist/src/interfaces/LocalCacheManagerInterface.d.ts

@@ -1,5 +1,5 @@
-import { LocalCache } from '../classes';
-export interface LocalCacheManagerInterface {
-    getCurrentLocalCache(userId: string): LocalCache;
-    getAllLocalCaches(): LocalCache[];
-}
+import { LocalCache } from '../classes';
+export interface LocalCacheManagerInterface {
+    getCurrentLocalCache(userId: string): LocalCache;
+    getAllLocalCaches(): LocalCache[];
+}

package/dist/src/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 '../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>;
+}

package/dist/src/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;
+}