@rentman/rm-core 1.6.1 → 1.6.2

package/dist/src/classes/ItemHandler.d.ts

@@ -1,60 +1,60 @@
-import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
-import { ENTRY_STATUS } from '../constants';
-import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry, ItemEntryOptions, Template } from '../models';
-import { ApiRequestColumns, ApiResponse, EntryParentNull, EntryStatus, ItemId, ItemIdConversionMap, ItemType, LinkedItemEntryMap, PromiseInterface, ResponseColumnMap, TemplateItemEntryMap } from '../types';
-export declare class ItemHandler {
-    private apiFormatter;
-    private apiRequestService;
-    private batchStatusFactory;
-    private columnExpansionFactory;
-    private columnHandler;
-    private columnSetFactory;
-    private columnSubsetCacheFactory;
-    private columnUtil;
-    private errorHandler;
-    private itemCacheFactory;
-    private itemEntryFactory;
-    private itemEntryService;
-    private keyService;
-    private promiseService;
-    private templateFactory;
-    entries: ItemCache;
-    templates: {
-        [itemType: string]: Template;
-    };
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
-    fetchItem(itemType: ItemType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
-    fetchNewItem(itemType: ItemType, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
-    createBatchStatus(itemType: ItemType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
-        batchStatus: BatchStatus<ItemEntry>;
-        success: boolean;
-    };
-    /**
-     * For every item ID find the status of the ItemEntry and resolve the promises so the result is
-     * a usable ItemEntry
-     */
-    fetchItems(itemType: ItemType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    handleBatchResponse(batchStatus: BatchStatus<ItemEntry>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnMap | null, columnExpansion?: ColumnExpansion): PromiseInterface<boolean>;
-    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
-    private getColumnDifference;
-    resolveLocal(itemEntry: ItemEntry, parent: EntryParentNull, template: Template, localItemCache: ItemCache): TemplateItemEntryMap;
-    resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
-    private clearItem;
-    private resolveRemote;
-    private resolveRemoteValues;
-    private getResponseFields;
-    fetchTemplate(itemType: ItemType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
-    getEntryStatus(itemType: ItemType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache): EntryStatus<ItemEntry> | null;
-    getCachedEntryStatus(itemEntry: ItemEntry, columnSubsetCache: ColumnSubsetCache): ENTRY_STATUS;
-    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
-    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry) => boolean): LinkedItemEntryMap[];
-    expandLocalEntries(itemType: ItemType, itemEntries: ItemEntry[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
-    private setDefaultValuesByColumn;
-    private getItemIdByColumn;
-    private fetchDerivedValuesByColumn;
-    requestItem(itemEntry: ItemEntry, requestColumns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestItems(itemType: ItemType, itemIds: ItemId[], columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-}
+import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSubsetCache, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
+import { ENTRY_STATUS } from '../constants';
+import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry, ItemEntryOptions, Template } from '../models';
+import { ApiRequestColumns, ApiResponse, EntryParentNull, EntryStatus, ItemId, ItemIdConversionMap, ItemType, LinkedItemEntryMap, PromiseInterface, ResponseColumnMap, TemplateItemEntryMap } from '../types';
+export declare class ItemHandler {
+    private apiFormatter;
+    private apiRequestService;
+    private batchStatusFactory;
+    private columnExpansionFactory;
+    private columnHandler;
+    private columnSetFactory;
+    private columnSubsetCacheFactory;
+    private columnUtil;
+    private errorHandler;
+    private itemCacheFactory;
+    private itemEntryFactory;
+    private itemEntryService;
+    private keyService;
+    private promiseService;
+    private templateFactory;
+    entries: ItemCache;
+    templates: {
+        [itemType: string]: Template;
+    };
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnSubsetCacheFactory: ColumnSubsetCacheFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
+    fetchItem(itemType: ItemType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    fetchNewItem(itemType: ItemType, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
+    createBatchStatus(itemType: ItemType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
+        batchStatus: BatchStatus<ItemEntry>;
+        success: boolean;
+    };
+    /**
+     * For every item ID find the status of the ItemEntry and resolve the promises so the result is
+     * a usable ItemEntry
+     */
+    fetchItems(itemType: ItemType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    handleBatchResponse(batchStatus: BatchStatus<ItemEntry>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnMap | null, columnExpansion?: ColumnExpansion): PromiseInterface<boolean>;
+    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    private getColumnDifference;
+    resolveLocal(itemEntry: ItemEntry, parent: EntryParentNull, template: Template, localItemCache: ItemCache): TemplateItemEntryMap;
+    resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
+    private clearItem;
+    private resolveRemote;
+    private resolveRemoteValues;
+    private getResponseFields;
+    fetchTemplate(itemType: ItemType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
+    getEntryStatus(itemType: ItemType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache): EntryStatus<ItemEntry> | null;
+    getCachedEntryStatus(itemEntry: ItemEntry, columnSubsetCache: ColumnSubsetCache): ENTRY_STATUS;
+    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
+    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry) => boolean): LinkedItemEntryMap[];
+    expandLocalEntries(itemType: ItemType, itemEntries: ItemEntry[], requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    private setDefaultValuesByColumn;
+    private getItemIdByColumn;
+    private fetchDerivedValuesByColumn;
+    requestItem(itemEntry: ItemEntry, requestColumns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestItems(itemType: ItemType, itemIds: ItemId[], columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+}

package/dist/src/classes/ItemRequestService.d.ts

@@ -1,23 +1,23 @@
-import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QueryService } from '../classes';
-import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { ApiQuery, ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class ItemRequestService {
-    private apiRequestService;
-    private errorHandler;
-    private itemHandler;
-    private columnExpansionFactory;
-    private columnSetFactory;
-    private itemEntryFactory;
-    private queryService;
-    private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseLibraryInterface);
-    requestItem(itemType: ItemType, itemId: ItemId, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestItems(collectionEntry: CollectionEntry, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestLinkItems(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    processExpansion(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
-    processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): PromiseInterface<ItemEntry[]>;
-    handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;
-    processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;
-}
+import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QueryService } from '../classes';
+import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
+import { ApiQuery, ApiRequestColumns, ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+export declare class ItemRequestService {
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    private columnExpansionFactory;
+    private columnSetFactory;
+    private itemEntryFactory;
+    private queryService;
+    private promiseService;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseLibraryInterface);
+    requestItem(itemType: ItemType, itemId: ItemId, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestItems(collectionEntry: CollectionEntry, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestLinkItems(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
+    processExpansion(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
+    processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): PromiseInterface<ItemEntry[]>;
+    handleCachedItem(itemEntry: ItemEntry, response: ApiResponse, columnExpansion: ColumnExpansion): ItemEntry;
+    processLinkResponse(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any): Promise<any>;
+}

package/dist/src/classes/KeyService.d.ts

@@ -1,16 +1,16 @@
-import { ItemId, StateKey } from '../types';
-export declare class KeyService {
-    separator: string;
-    constructor();
-    getSingleKey(itemType: string, itemId: number | string): string;
-    getCssKey(): string;
-    parseStateKey(stateKey: string): StateKey | null;
-    getDuplicateStateKey(itemId: string | number): string;
-    getNewStateKey(templateType: string): string;
-    getLocalId(): ItemId;
-    getLocalDuplicateId(): ItemId;
-    getRandomString(): string;
-    isLocalId(itemId: ItemId | string): boolean;
-    isNewId(itemId: ItemId | string): boolean;
-    isDuplicateId(itemId: ItemId | string): boolean;
-}
+import { ItemId, StateKey } from '../types';
+export declare class KeyService {
+    separator: string;
+    constructor();
+    getSingleKey(itemType: string, itemId: number | string): string;
+    getCssKey(): string;
+    parseStateKey(stateKey: string): StateKey | null;
+    getDuplicateStateKey(itemId: string | number): string;
+    getNewStateKey(templateType: string): string;
+    getLocalId(): ItemId;
+    getLocalDuplicateId(): ItemId;
+    getRandomString(): string;
+    isLocalId(itemId: ItemId | string): boolean;
+    isNewId(itemId: ItemId | string): boolean;
+    isDuplicateId(itemId: ItemId | string): boolean;
+}

package/dist/src/classes/LocalCache.d.ts

@@ -1,96 +1,96 @@
-import { CollectionCache, ItemCache, LockService } from '../classes';
-import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
-import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
-export declare class LocalCache {
-    private changesProcessorFactory;
-    private collectionCacheFactory;
-    private collectionResourceFactory;
-    private errorHandler;
-    private exceptionHandler;
-    private itemCacheFactory;
-    private itemResourceFactory;
-    private lockService;
-    private promiseService;
-    id: string;
-    items: ItemCache;
-    rootItem: ItemEntry | undefined;
-    collections: CollectionCache;
-    deferredCollections: CollectionCache;
-    tabRequestParameters: {};
-    isSaving: boolean;
-    private callbacks;
-    private changesInterval;
-    hasChanges: boolean;
-    constructor(changesProcessorFactory: ChangesProcessorFactory, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id?: string);
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean, isNew?: boolean): EditResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource;
-    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource;
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
-        edit: true;
-    }): EditResource[];
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
-        remote: true;
-    }): RemoteViewResource[];
-    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): LocalViewResource[];
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
-        editItems: true;
-        editCollection: true;
-    }): CollectionEditResource<EditResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
-        remoteItems: true;
-        editCollection: true;
-    }): CollectionEditResource<RemoteViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
-        editCollection: true;
-    }): CollectionEditResource<LocalViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
-        editItems: true;
-    }): CollectionViewResource<EditResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
-        remoteItems: true;
-    }): CollectionViewResource<RemoteViewResource>;
-    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionViewResource<LocalViewResource>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
-        editItems: true;
-        editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<EditResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
-        remoteItems: true;
-        editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
-        editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
-        editItems: true;
-    }): CollectionResourceParentIdMap<CollectionViewResource<EditResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
-        remoteItems: true;
-    }): CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>;
-    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>;
-    clearItem(itemResource: ItemResource): void;
-    clearItemEntry(itemEntry: ItemEntry): void;
-    clearCollection(collectionResource: CollectionResource): void;
-    clearResources(isSubTabChange?: boolean): void;
-    updateSingleItems(conversionMap: ItemIdConversionMap): void;
-    revertChanges(): PromiseInterface<void>;
-    resetCollection(collectionEntry: CollectionEntry): void;
-    detectChanges(): boolean;
-    private collectionHasChanges;
-    isLockable(): boolean;
-    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
-    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
-    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
-    private executeCallbackEvent;
-    private executeCallbacks;
-    enableChangesWatcher(): void;
-    disableChangesWatcher(): void;
-    onDeactivateItem(itemEntry: ItemEntry): void;
-    onActivateItem(itemEntry: ItemEntry): void;
-}
+import { CollectionCache, ItemCache, LockService } from '../classes';
+import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
+import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, LocalViewResource, RemoteViewResource } from '../models';
+import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptionsInterface, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface } from '../types';
+export declare class LocalCache {
+    private changesProcessorFactory;
+    private collectionCacheFactory;
+    private collectionResourceFactory;
+    private errorHandler;
+    private exceptionHandler;
+    private itemCacheFactory;
+    private itemResourceFactory;
+    private lockService;
+    private promiseService;
+    id: string;
+    items: ItemCache;
+    rootItem: ItemEntry | undefined;
+    collections: CollectionCache;
+    deferredCollections: CollectionCache;
+    tabRequestParameters: {};
+    isSaving: boolean;
+    private callbacks;
+    private changesInterval;
+    hasChanges: boolean;
+    constructor(changesProcessorFactory: ChangesProcessorFactory, collectionCacheFactory: CollectionCacheFactory, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, itemCacheFactory: ItemCacheFactory, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id?: string);
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+        edit: true;
+    }, isRoot?: boolean, isNew?: boolean): EditResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface & {
+        remote: true;
+    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource;
+    createItemResource(itemEntry: ItemEntry, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource;
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
+        edit: true;
+    }): EditResource[];
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface & {
+        remote: true;
+    }): RemoteViewResource[];
+    createItemResources(itemEntries: ItemEntry[], options: ItemOptionsInterface): LocalViewResource[];
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionEditResource<EditResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        remoteItems: true;
+        editCollection: true;
+    }): CollectionEditResource<RemoteViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }): CollectionEditResource<LocalViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }): CollectionViewResource<EditResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface & {
+        remoteItems: true;
+    }): CollectionViewResource<RemoteViewResource>;
+    createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: CollectionResourceOptionsInterface): CollectionViewResource<LocalViewResource>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<EditResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        remoteItems: true;
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<RemoteViewResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        editCollection: true;
+    }): CollectionResourceParentIdMap<CollectionEditResource<LocalViewResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        editItems: true;
+    }): CollectionResourceParentIdMap<CollectionViewResource<EditResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface & {
+        remoteItems: true;
+    }): CollectionResourceParentIdMap<CollectionViewResource<RemoteViewResource>>;
+    createCollectionResources(collectionEntries: CollectionEntryParentIdMap, resourceOptions: CollectionResourceOptionsInterface): CollectionResourceParentIdMap<CollectionViewResource<LocalViewResource>>;
+    clearItem(itemResource: ItemResource): void;
+    clearItemEntry(itemEntry: ItemEntry): void;
+    clearCollection(collectionResource: CollectionResource): void;
+    clearResources(isSubTabChange?: boolean): void;
+    updateSingleItems(conversionMap: ItemIdConversionMap): void;
+    revertChanges(): PromiseInterface<void>;
+    resetCollection(collectionEntry: CollectionEntry): void;
+    detectChanges(): boolean;
+    private collectionHasChanges;
+    isLockable(): boolean;
+    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
+    onBeforeSave(key: string, callback: (localCache: LocalCache) => any, condition?: LocalCacheCallbackCondition): () => void;
+    onSaveSuccess(key: string, callback: OnSaveCallback, condition?: LocalCacheCallbackCondition): () => void;
+    private executeCallbackEvent;
+    private executeCallbacks;
+    enableChangesWatcher(): void;
+    disableChangesWatcher(): void;
+    onDeactivateItem(itemEntry: ItemEntry): void;
+    onActivateItem(itemEntry: ItemEntry): void;
+}

package/dist/src/classes/LockService.d.ts

@@ -1,32 +1,32 @@
-import { KeyService } from '../classes';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ItemId, ItemMap, PromiseInterface } from '../types';
-export declare type LockToken = {
-    isForeign: false;
-    id: number;
-    token: string;
-} | {
-    isForeign: true;
-    message: string;
-};
-export declare class LockService {
-    private apiRequestService;
-    private errorHandler;
-    private keyService;
-    private promiseService;
-    lockItems: ItemMap<LockToken>;
-    promises: ItemMap<PromiseInterface<LockToken>>;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    private getValue;
-    private setValue;
-    getLocks(): this['lockItems'];
-    hasLock(lockTokenId: ItemId): boolean;
-    isLocked(itemEntry: ItemEntry): boolean;
-    getMessage(itemEntry: ItemEntry): undefined | string;
-    fetchCachedLock(itemEntry: ItemEntry): PromiseInterface<undefined | LockToken>;
-    fetchLock(itemEntry: ItemEntry): PromiseInterface<string>;
-    requestLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
-    deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
-    clearLock(itemEntry: ItemEntry): boolean;
-}
+import { KeyService } from '../classes';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry } from '../models';
+import { ItemId, ItemMap, PromiseInterface } from '../types';
+export declare type LockToken = {
+    isForeign: false;
+    id: number;
+    token: string;
+} | {
+    isForeign: true;
+    message: string;
+};
+export declare class LockService {
+    private apiRequestService;
+    private errorHandler;
+    private keyService;
+    private promiseService;
+    lockItems: ItemMap<LockToken>;
+    promises: ItemMap<PromiseInterface<LockToken>>;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    private getValue;
+    private setValue;
+    getLocks(): this['lockItems'];
+    hasLock(lockTokenId: ItemId): boolean;
+    isLocked(itemEntry: ItemEntry): boolean;
+    getMessage(itemEntry: ItemEntry): undefined | string;
+    fetchCachedLock(itemEntry: ItemEntry): PromiseInterface<undefined | LockToken>;
+    fetchLock(itemEntry: ItemEntry): PromiseInterface<string>;
+    requestLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry): boolean;
+}

package/dist/src/classes/ModuleChangesCompilation.d.ts

@@ -1,21 +1,21 @@
-import { CollectionCache, ItemCache } from '../classes';
-import { ItemEntry } from '../models';
-import { ApiRequestItemMap, ItemId, ItemType } from '../types';
-export declare type ModuleChangesCompilationResult = {
-    itemType: ItemType;
-    itemId: ItemId;
-    items: ApiRequestItemMap;
-};
-export declare class ModuleChangesCompilation {
-    private rootItemEntry;
-    private singleItemCache;
-    private collectionCache;
-    parentMap: any;
-    destination: ApiRequestItemMap;
-    constructor(rootItemEntry: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache);
-    process(): ModuleChangesCompilationResult;
-    private createParentMap;
-    private processItems;
-    private processItem;
-    private getItemsByParent;
-}
+import { CollectionCache, ItemCache } from '../classes';
+import { ItemEntry } from '../models';
+import { ApiRequestItemMap, ItemId, ItemType } from '../types';
+export declare type ModuleChangesCompilationResult = {
+    itemType: ItemType;
+    itemId: ItemId;
+    items: ApiRequestItemMap;
+};
+export declare class ModuleChangesCompilation {
+    private rootItemEntry;
+    private singleItemCache;
+    private collectionCache;
+    parentMap: any;
+    destination: ApiRequestItemMap;
+    constructor(rootItemEntry: ItemEntry, singleItemCache: ItemCache, collectionCache: CollectionCache);
+    process(): ModuleChangesCompilationResult;
+    private createParentMap;
+    private processItems;
+    private processItem;
+    private getItemsByParent;
+}

package/dist/src/classes/QueryMatcher.d.ts

@@ -1,14 +1,14 @@
-import { ApiFormatter } from '../classes';
-import { EntryParentNull, FieldMap, ItemType } from '../types';
-export declare class QueryMatcher {
-    private apiFormatter;
-    itemType: ItemType;
-    fields: FieldMap;
-    parent: EntryParentNull;
-    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
-    private compareValues;
-    matchQuery(query: any): boolean | 'maybe';
-    private matchLinkedToQuery;
-    private matchComplexQuery;
-    private matchSimpleQuery;
-}
+import { ApiFormatter } from '../classes';
+import { EntryParentNull, FieldMap, ItemType } from '../types';
+export declare class QueryMatcher {
+    private apiFormatter;
+    itemType: ItemType;
+    fields: FieldMap;
+    parent: EntryParentNull;
+    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
+    private compareValues;
+    matchQuery(query: any): boolean | 'maybe';
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
+}

package/dist/src/classes/QueryParser.d.ts

@@ -1,19 +1,19 @@
-import { ApiQuery } from '../types';
-export declare class QueryParser {
-    query: ApiQuery;
-    parameters: any;
-    constructor(query: ApiQuery, parameters?: object);
-    private compareParsedQueries;
-    parse(query?: ApiQuery): [object, string];
-    private parseSubQuery;
-    private parseSubFieldQuery;
-    private parseSearchQuery;
-    private parseCustomQuery;
-    private parseCustomParameters;
-    private parseSimpleQuery;
-    private parseLinkedToQuery;
-    private parseComplexQuery;
-    private parseConditions;
-    private formatValue;
-    private processValue;
-}
+import { ApiQuery } from '../types';
+export declare class QueryParser {
+    query: ApiQuery;
+    parameters: any;
+    constructor(query: ApiQuery, parameters?: object);
+    private compareParsedQueries;
+    parse(query?: ApiQuery): [object, string];
+    private parseSubQuery;
+    private parseSubFieldQuery;
+    private parseSearchQuery;
+    private parseCustomQuery;
+    private parseCustomParameters;
+    private parseSimpleQuery;
+    private parseLinkedToQuery;
+    private parseComplexQuery;
+    private parseConditions;
+    private formatValue;
+    private processValue;
+}

package/dist/src/classes/QueryService.d.ts

@@ -1,8 +1,8 @@
-import { ApiQuery, EntryParentNull, ItemId } from '../types';
-export declare class QueryService {
-    constructor();
-    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
-    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
-    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
-    createNotIn(idArray: ItemId[]): ApiQuery;
-}
+import { ApiQuery, EntryParentNull, ItemId } from '../types';
+export declare class QueryService {
+    constructor();
+    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
+    createNotIn(idArray: ItemId[]): ApiQuery;
+}

package/dist/src/classes/RequestColumnExpansion.d.ts

@@ -1,14 +1,14 @@
-import { ColumnSet, ColumnUtil } from '../classes';
-import { ApiRequestColumns } from '../types';
-declare type RequestColumnMap = {
-    [itemType: string]: ApiRequestColumns;
-};
-export declare class RequestColumnExpansion {
-    private columnUtil;
-    private columns;
-    private columnSetIdMap;
-    constructor(columnUtil: ColumnUtil);
-    expand(columnSet: ColumnSet): void;
-    get(): RequestColumnMap;
-}
-export {};
+import { ColumnSet, ColumnUtil } from '../classes';
+import { ApiRequestColumns } from '../types';
+declare type RequestColumnMap = {
+    [itemType: string]: ApiRequestColumns;
+};
+export declare class RequestColumnExpansion {
+    private columnUtil;
+    private columns;
+    private columnSetIdMap;
+    constructor(columnUtil: ColumnUtil);
+    expand(columnSet: ColumnSet): void;
+    get(): RequestColumnMap;
+}
+export {};