@rentman/rm-core 1.9.0 → 2.0.1

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

@@ -1,54 +0,0 @@
-import { CollectionEntryOptions, CollectionViewResource, PromiseInterface } from '../';
-import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
-import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource } from '../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, QueryCallback } from '../types';
-export declare class CollectionHandler {
-    private batchStatusFactory;
-    private collectionCacheFactory;
-    private collectionEntryFactory;
-    private collectionEntryService;
-    private collectionMatcherFactory;
-    private columnHandler;
-    private columnSetFactory;
-    private errorHandler;
-    private itemHandler;
-    private itemRequestService;
-    private keyService;
-    private promiseService;
-    private queryParserFactory;
-    private queryService;
-    entries: CollectionCache;
-    constructor(batchStatusFactory: BatchStatusFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryParserFactory: QueryParserFactory, queryService: QueryService);
-    /**
-     * @deprecated use {@link CollectionMatcherFactory CollectionMatcherFactory}
-     */
-    removeFromAndAddToCollections(collectionMap: any): void;
-    getCollectionMatcher<ItemTypeType extends ItemType>(): CollectionMatcher<ItemTypeType>;
-    /**
-     * @deprecated use {@link CollectionMatcherFactory CollectionMatcherFactory}
-     */
-    removeFromCollections<T extends CollectionResource<any> = CollectionViewResource<any>>(collectionMap: any, updateInitial?: boolean, resultResource?: T | null): T['items'] | null;
-    /**
-     * @deprecated use {@link CollectionMatcherFactory CollectionMatcherFactory}
-     */
-    addToCollections<T extends CollectionResource<any> = CollectionViewResource<any>>(collectionMap: any, updateInitial: boolean, resultResource?: T | null): T['items'];
-    batchExpand<ItemTypeType extends ItemType>(parentType: ItemType, itemType: ItemTypeType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    batchExtend<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T, returnAllItems?: boolean, callOnAdd?: boolean): PromiseInterface<ItemResourceItemIdMap>;
-    batchFetch<ItemTypeType extends ItemType>(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntryParentIdMap<ItemTypeType>>;
-    handleBatchResponse<ItemTypeType extends ItemType>(batchStatus: BatchStatus<ItemTypeType, CollectionEntry<ItemTypeType>>, itemEntryCompound: {
-        columns: ColumnSet<ItemTypeType>;
-        columnExpansion?: ColumnExpansion<ItemTypeType>;
-        items?: ItemEntryParentIdMap<ItemTypeType>;
-    }, localItems: ItemEntryParentIdMap<ItemTypeType>): CollectionEntryParentIdMap<ItemTypeType>;
-    fetch<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry<ItemTypeType>>;
-    private resolveCached;
-    private getCachedEntryStatus;
-    private getDeferredEntryStatus;
-    private getEntryStatus;
-    resolveLocal<T extends CollectionEntry<any>>(collectionEntry: T, itemCache: ItemCache): PromiseInterface<T>;
-    resolveRemote<T extends CollectionEntry<any>>(collectionEntry: T, itemCache: ItemCache): PromiseInterface<T>;
-    isLocal(options: any): boolean;
-    private expandLocalItemEntries;
-}

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

@@ -1,228 +0,0 @@
-import { CollectionCache, CollectionHandler, CollectionMatcher, ItemCache, ItemHandler, ItemRequestService, KeyService, LocalCache, LocalCacheCallbackCondition, LocalCacheCallbackType, ModuleChangesCompilationResult, QueryService } from '../classes';
-import { CollectionMatcherFactory, ColumnSetFactory, ModuleChangesCompilationFactory } from '../factories';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEditResource, CollectionEntry, CollectionResource, CollectionResourceOptionsInterface, CollectionViewResource, EditResource, ItemEntry, ItemResource, ItemResourceOptionsInterface, LocalViewResource, RemoteViewResource } from '../models';
-import { ApiQuery, CollectionDefinition, CollectionOptionsInterface, CollectionResourceParentIdMap, ConversionMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemResourcesItemTypeMap, ItemType, LinkCollectionDefinition, LinkedItemEntryMap, PromiseInterface } from '../types';
-declare type EditResourceLinks<ItemTypeType extends ItemType> = {
-    main: EditResource<ItemTypeType>;
-    linked: ItemResourcesItemTypeMap;
-};
-export declare class ItemAdministrator {
-    private apiRequestService;
-    private authInterface;
-    private collectionHandler;
-    private collectionMatcherFactory;
-    private columnSetFactory;
-    private errorHandler;
-    private itemHandler;
-    private itemRequestService;
-    private keyService;
-    private localCacheManager;
-    private moduleChangesCompilationFactory;
-    private promiseInterface;
-    private queryService;
-    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseLibraryInterface, queryService: QueryService);
-    invalidateCache(): void;
-    getCollectionMatcher<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, addToTab?: boolean, callOnAdd?: boolean): CollectionMatcher<ItemTypeType>;
-    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest?: boolean): PromiseInterface<string>;
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
-    getItemById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface & {
-        edit: true;
-    }): PromiseInterface<Array<EditResource<ItemTypeType>>>;
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface & {
-        remote: true;
-    }): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
-    getItemsById<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemOptionsInterface): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface & {
-        edit: true;
-    }): PromiseInterface<Array<EditResource<ItemTypeType>>>;
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface & {
-        remote: true;
-    }): PromiseInterface<Array<RemoteViewResource<ItemTypeType>>>;
-    getItemsByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: ApiQuery, options: ItemOptionsInterface): PromiseInterface<Array<LocalViewResource<ItemTypeType>>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
-    getNewResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
-    getNewResourceWithId<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks: true, isRoot?: boolean): PromiseInterface<EditResourceLinks<ItemTypeType>>;
-    getDuplicateById<ItemTypeType extends ItemType>(itemType: ItemTypeType, duplicateId: ItemId, options: ItemOptionsInterface, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean): PromiseInterface<EditResource<ItemTypeType>>;
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean): PromiseInterface<RemoteViewResource<ItemTypeType>>;
-    getItemByState<ItemTypeType extends ItemType>(itemType: ItemTypeType, stateKey: ItemId | string, options: ItemOptionsInterface, isRoot?: boolean): PromiseInterface<LocalViewResource<ItemTypeType>>;
-    getCollectionDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): CollectionDefinition<ItemTypeType>;
-    getLinkCollectionsDef<ItemTypeType extends ItemType>(itemType: ItemTypeType, linkField: string, options: CollectionOptionsInterface<ItemTypeType>): LinkCollectionDefinition<ItemTypeType>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-        editItems: true;
-    }): PromiseInterface<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): PromiseInterface<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-        remoteItems: true;
-    }): PromiseInterface<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): PromiseInterface<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): PromiseInterface<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    getCollection<ItemTypeType extends ItemType>(itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    getCollectionFromDef<ItemTypeType extends ItemType>(definition: CollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResource<ItemTypeType>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    getLinkCollectionsFromDef<ItemTypeType extends ItemType>(linkType: ItemType, linkIdArray: ItemId[], definition: LinkCollectionDefinition<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionResource<ItemTypeType>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>>;
-    getAllLinkCollections<ItemTypeType extends ItemType>(linkType: ItemType, itemType: ItemTypeType, options: CollectionOptionsInterface<ItemTypeType>): PromiseInterface<CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>>;
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface & {
-        edit: true;
-    }): EditResource<ItemTypeType>;
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface & {
-        remote: true;
-    }): RemoteViewResource<ItemTypeType>;
-    cloneItem<ItemTypeType extends ItemType>(itemResource: ItemResource<ItemTypeType>, options: ItemOptionsInterface): LocalViewResource<ItemTypeType>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }, conversionMap: ItemIdConversionMap): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    cloneCollection<ItemTypeType extends ItemType>(collectionResource: CollectionResource<ItemTypeType>, options: CollectionOptionsInterface<ItemTypeType>, conversionMap: ItemIdConversionMap): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
-    getCurrentCollections(): CollectionCache;
-    getCurrentItems(): ItemCache;
-    getModuleChanges(localCache?: LocalCache): ModuleChangesCompilationResult;
-    addSingleItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean, localCache?: LocalCache): EditResource<ItemTypeType>;
-    addSingleItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean, localCache?: LocalCache): RemoteViewResource<ItemTypeType>;
-    addSingleItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface, isRoot?: boolean, localCache?: LocalCache): LocalViewResource<ItemTypeType>;
-    addSingleItems<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemResourceOptionsInterface & {
-        edit: true;
-    }): Array<EditResource<ItemTypeType>>;
-    addSingleItems<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemResourceOptionsInterface & {
-        remote: true;
-    }): Array<RemoteViewResource<ItemTypeType>>;
-    addSingleItems<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemResourceOptionsInterface): Array<LocalViewResource<ItemTypeType>>;
-    addCollection<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-        editItems: true;
-    }): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    addCollection<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    addCollection<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-        remoteItems: true;
-    }): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    addCollection<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    addCollection<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    addCollection<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, options: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    private createItemResources;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: Array<LinkedItemEntryMap<ItemTypeType>>, options: ItemOptionsInterface & {
-        edit: true;
-    }, addToCollections?: boolean): ItemResourcesItemTypeMap<EditResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: Array<LinkedItemEntryMap<ItemTypeType>>, options: ItemOptionsInterface & {
-        remote: true;
-    }, addToCollections?: boolean): ItemResourcesItemTypeMap<RemoteViewResource<ItemTypeType>>;
-    processLinkedItems<ItemTypeType extends ItemType>(linkedEntries: Array<LinkedItemEntryMap<ItemTypeType>>, options: ItemOptionsInterface, addToCollections?: boolean): ItemResourcesItemTypeMap<LocalViewResource<ItemTypeType>>;
-    expandProcessLinkedItems<ItemTypeType extends ItemType>(linkedEntries: Array<LinkedItemEntryMap<ItemTypeType>>): PromiseInterface<void>;
-    private constructOnItemsExpanded;
-    private expandAddToCollections;
-    private getColumnSuperset;
-    getLocalCache(): LocalCache;
-    addToCollections<ItemTypeType extends ItemType, T extends CollectionResource<ItemTypeType> = CollectionViewResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultCollectionResource: T, callOnAdd?: boolean): T['items'];
-    addToCollections<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultCollectionResource?: null, callOnAdd?: boolean): null;
-    removeFromCollections<ItemTypeType extends ItemType, T extends CollectionResource<ItemTypeType> = CollectionViewResource<ItemTypeType>>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultCollectionResource: T): T['items'];
-    removeFromCollections<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, resultCollectionResource?: null): null;
-    saveLocal(itemResource: ItemResource<any>): PromiseInterface<ItemResource<any>>;
-    updateItemIdMap(collectionMap: any, conversionMap: ConversionMap): void;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean): EditResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean): RemoteViewResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemResourceOptionsInterface, isRoot?: boolean): LocalViewResource<ItemTypeType>;
-    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-}
-export {};

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

@@ -1,60 +0,0 @@
-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, ResponseColumnItemTypeMap, 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<any>;
-    };
-    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<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
-    fetchNewItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap<ItemTypeType>>;
-    createBatchStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], parent: EntryParentNull, requestColumns: ApiRequestColumns, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean): {
-        batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>;
-        success: boolean;
-    };
-    /**
-     * @description
-     * For every {@link ItemEntry.itemId ItemId}, find the status of the {@link ItemEntry ItemEntry} and resolve the promises so the result is a usable {@link ItemEntry ItemEntry}
-     */
-    fetchItems<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    handleBatchResponse<ItemTypeType extends ItemType>(batchStatus: BatchStatus<ItemTypeType, ItemEntry<ItemTypeType>>, localItemCache: ItemCache, requestColumns: ApiRequestColumns, response: ApiResponseProcessor | null, responseColumns: ResponseColumnItemTypeMap | null, columnExpansion?: ColumnExpansion<ItemTypeType>): PromiseInterface<boolean>;
-    resolveCached<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, status: ENTRY_STATUS, options: ItemEntryOptions, localItemCache: ItemCache): PromiseInterface<ItemEntry<ItemTypeType>>;
-    private getColumnDifference;
-    resolveLocal<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, parent: EntryParentNull, template: Template<ItemTypeType>, localItemCache: ItemCache): TemplateItemEntryMap<ItemTypeType>;
-    resolveExpansion<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>, response: ApiResponse): ItemEntry<ItemTypeType>;
-    private clearItem;
-    private resolveRemote;
-    private resolveRemoteValues;
-    private getResponseFields;
-    fetchTemplate<ItemTypeType extends ItemType>(itemType: ItemTypeType, templateOptions?: any, templateColumns?: any): PromiseInterface<Template<ItemTypeType>>;
-    getEntryStatus<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, deferRequest: boolean, localItemCache: ItemCache, addToLocalCache: boolean, columnSubsetCache: ColumnSubsetCache<ItemTypeType>): EntryStatus<ItemEntry<ItemTypeType>> | null;
-    getCachedEntryStatus<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>): ENTRY_STATUS;
-    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
-    createLocalEntries(parentType: ItemType, localParentId: ItemId, template: Template<ItemType>, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, filterItemEntry?: (itemEntry: ItemEntry<ItemType>) => boolean): Array<LinkedItemEntryMap<ItemType>>;
-    expandLocalEntries<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnItemTypeMap, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    resolveDerivedValues<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, columns: Array<ColumnInfo<ItemTypeType>>, localItemCache: ItemCache): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    private setDefaultValuesByColumn;
-    private getItemIdByColumn;
-    private fetchDerivedValuesByColumn;
-    requestItem(itemEntry: ItemEntry<any>, requestColumns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestItems(itemType: ItemType, itemIds: ItemId[], columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-}

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

@@ -1,23 +0,0 @@
-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<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, query?: ApiQuery, columns?: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    requestLinkItems(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, query: ApiQuery, columns: ApiRequestColumns): PromiseInterface<ApiResponseProcessor>;
-    processExpansion<ItemTypeType extends ItemType>(requestColumns: ApiRequestColumns, response: ApiResponse, itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>): ColumnExpansion<ItemTypeType>;
-    processResponse<ItemTypeType extends ItemType>(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet<ItemTypeType>, columnExpansion?: ColumnExpansion<ItemTypeType>): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    handleCachedItem<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, response: ApiResponse, columnExpansion: ColumnExpansion<ItemTypeType>): ItemEntry<ItemTypeType>;
-    processLinkResponse<ItemTypeType extends ItemType>(response: ApiResponse, parentType: ItemType, parentIdArray: ItemId[], itemType: ItemTypeType, options: any): Promise<any>;
-}

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

@@ -1,112 +0,0 @@
-import { ChangesProcessor, CollectionCache, ItemCache, LocalCacheCallbackCondition, LocalCacheCallbackType, LockService } from '../classes';
-import { 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, ItemType, PromiseInterface } from '../types';
-/**
- * @description
- * The {@link LocalCache LocalCache} is responsible for keeping track of {@link ItemEntry ItemEntries} and {@link CollectionEntry CollectionEntries} which might have changes
- * in order to save them efficiently.
- *
- * @remarks
- * - Local entries are *not* stored in the global cache until they are saved.
- * - Remote entries *are* stored in the global cache, and can also be stored in the LocalCache.
- */
-export declare class LocalCache {
-    private changesProcessor;
-    private collectionResourceFactory;
-    private errorHandler;
-    private itemResourceFactory;
-    private lockService;
-    private promiseService;
-    id: string;
-    readonly items: ItemCache;
-    readonly collections: CollectionCache;
-    readonly deferredCollections: CollectionCache;
-    rootItem: ItemEntry<any> | undefined;
-    tabRequestParameters: {};
-    isSaving: boolean;
-    private changesInterval;
-    hasChanges: boolean;
-    private eventHandler;
-    constructor(exceptionHandler: ExceptionHandlerInterface, collectionCacheFactory: CollectionCacheFactory, itemCacheFactory: ItemCacheFactory, changesProcessor: ChangesProcessor, collectionResourceFactory: CollectionResourceFactory, errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, lockService: LockService, promiseService: PromiseLibraryInterface, id: string);
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        edit: true;
-    }, isRoot?: boolean, isNew?: boolean): EditResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface & {
-        remote: true;
-    }, isRoot?: boolean, isNew?: boolean): RemoteViewResource<ItemTypeType>;
-    createItemResource<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, options: ItemOptionsInterface, isRoot?: boolean, isNew?: boolean): LocalViewResource<ItemTypeType>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
-        edit: true;
-    }): Array<EditResource<ItemTypeType>>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface & {
-        remote: true;
-    }): Array<RemoteViewResource<ItemTypeType>>;
-    createItemResources<ItemTypeType extends ItemType>(itemEntries: Array<ItemEntry<ItemTypeType>>, options: ItemOptionsInterface): Array<LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>;
-    createCollectionResource<ItemTypeType extends ItemType>(collectionEntry: CollectionEntry<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-        editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-        editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editCollection: true;
-    }): CollectionResourceParentIdMap<CollectionEditResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        editItems: true;
-    }): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, EditResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType> & {
-        remoteItems: true;
-    }): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, RemoteViewResource<ItemTypeType>>>;
-    createCollectionResources<ItemTypeType extends ItemType>(collectionEntries: CollectionEntryParentIdMap<ItemTypeType>, resourceOptions: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResourceParentIdMap<CollectionViewResource<ItemTypeType, LocalViewResource<ItemTypeType>>>;
-    /**
-     * @description
-     * Removes an {@link ItemEntry ItemEntry} through an {@link ItemResource ItemResource} from the {@link LocalCache LocalCache} which means that changes on this entry will no longer be tracked.
-     */
-    clearItem(itemResource: ItemResource<any>): void;
-    /**
-     * @description
-     * Removes an {@link ItemEntry ItemEntry} from the {@link LocalCache LocalCache} which means that changes on this entry will no longer be tracked.
-     */
-    clearItemEntry(itemEntry: ItemEntry<any>): void;
-    /**
-     * @description
-     * Removes a {@link CollectionEntry CollectionEntry} through a {@link CollectionResource CollectionResource} from the {@link LocalCache LocalCache} which means that changes on this collection will no longer be tracked.
-     */
-    clearCollection(collectionResource: CollectionResource<any>): void;
-    clearDeferredCollections(): void;
-    updateSingleItems(conversionMap: ItemIdConversionMap): void;
-    revertChanges(): PromiseInterface<void>;
-    resetCollection(collectionEntry: CollectionEntry<any>): void;
-    detectChanges(): boolean;
-    private collectionHasChanges;
-    isLockable(): boolean;
-    save(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakUpByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
-    onBeforeSave(key: string, callback: LocalCacheCallbackType['onBeforeSave'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    onSaveSuccess(key: string, callback: LocalCacheCallbackType['onSaveSuccess'], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    enableChangesWatcher(): void;
-    disableChangesWatcher(): void;
-    onDeactivateItem(itemEntry: ItemEntry<any>): void;
-    onActivateItem(itemEntry: ItemEntry<any>): void;
-}

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

@@ -1,19 +0,0 @@
-import { LocalCache } from '../classes';
-import { ErrorHandlerInterface, ExceptionHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemIdConversionMap, PromiseInterface } from '../types';
-export declare type LocalCacheCallbackCondition = 'always' | 'onClose' | 'skipOnClose';
-export declare type LocalCacheCallbackType = {
-    onBeforeSave: (localCache: LocalCache) => any;
-    onSaveSuccess: (localCache: LocalCache, conversionMap: ItemIdConversionMap) => any;
-};
-export declare class LocalCacheEventHandler {
-    private errorHandler;
-    private exceptionHandler;
-    private promiseService;
-    private callbacks;
-    constructor(errorHandler: ErrorHandlerInterface, exceptionHandler: ExceptionHandlerInterface, promiseService: PromiseLibraryInterface);
-    registerCallback<T extends keyof LocalCacheCallbackType>(type: T, key: string, callback: LocalCacheCallbackType[T], condition?: LocalCacheCallbackCondition, priority?: number): () => void;
-    executeCallbacks<T extends keyof LocalCacheCallbackType>(type: T, execute: (callback: LocalCacheCallbackType[T]) => any, closeTab: boolean): PromiseInterface<any>;
-    private getPriorityLevel;
-    private executeCallbacksPriorityLevel;
-}

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

@@ -1,9 +0,0 @@
-import { BatchStatus } from '../classes';
-import { PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { ItemId, ItemType, PromiseInterface } from '../types';
-export declare class BatchStatusFactory {
-    private promiseService;
-    constructor(promiseService: PromiseLibraryInterface);
-    construct<ItemTypeType extends ItemType, T extends ItemEntry<ItemTypeType> | CollectionEntry<ItemTypeType>>(itemType: ItemTypeType, getItemId: (entry: T) => ItemId, getPromise: (entry: T) => PromiseInterface<T>): BatchStatus<ItemTypeType, T>;
-}

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

@@ -1,16 +0,0 @@
-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): LocalCache;
-}

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

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