@rentman/rm-core 1.2.9 → 1.3.1

package/dist/{dist → src}/classes/ApiFormatter.d.ts

@@ -30,7 +30,7 @@ export declare class ApiFormatter {
     formatRequestDate(value: any): any;
     formatRequestDuration(value: any): any;
     formatRequestColor(value: any): any;
-    getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
+    getDefaultValue(columnType: any): false | moment.Moment | 0 | moment.Duration | "" | "0" | "#000000" | null;
     isDefaultValue(columnType: any, value: any): boolean;
     clone(columnType: any, value: any): any;
     getCloneFunction(columnType: any): (date: any) => any;

package/dist/{dist → src}/classes/ApiRequestService.d.ts

@@ -1,18 +1,18 @@
 import { ApiResponseProcessor } from '../classes';
 import { ApiResponseProcessorFactory } from '../factories';
 import { ApiRequestServiceInterface } from '../interfaces';
-import { ItemId, ItemType } from '../types';
+import { ItemId, ItemType, PromiseInterface } from '../types';
 export declare class ApiRequestService {
     private externalApiRequestService;
     private apiResponseProcessorFactory;
     constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    template(itemType: ItemType, params: any): Promise<ApiResponseProcessor>;
-    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): Promise<ApiResponseProcessor>;
-    delete(itemType: ItemType, itemIds: ItemId[]): Promise<ApiResponseProcessor>;
-    updateItems(itemType: ItemType, items: object, columns: any): Promise<ApiResponseProcessor>;
-    requestSkeleton(params: any, requestCanceler?: Promise<any>): Promise<ApiResponseProcessor>;
-    moveItems(parentType: ItemType, parentId: ItemId, items: object): Promise<ApiResponseProcessor>;
-    columns(itemType: ItemType, columns: object, params?: any): Promise<ApiResponseProcessor>;
-    query(itemType: ItemType, query: object, columns: object, limit?: object): Promise<ApiResponseProcessor>;
-    processResponse(request: any): Promise<ApiResponseProcessor>;
+    template(itemType: ItemType, params: any): PromiseInterface<ApiResponseProcessor>;
+    create(itemType: ItemType, itemId: ItemId, values: any, parentType?: ItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
+    delete(itemType: ItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
+    updateItems(itemType: ItemType, items: object, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: object): PromiseInterface<ApiResponseProcessor>;
+    columns(itemType: ItemType, columns: object, params?: any): PromiseInterface<ApiResponseProcessor>;
+    query(itemType: ItemType, query: object, columns: object, limit?: object): PromiseInterface<ApiResponseProcessor>;
+    processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
 }

package/dist/{dist → src}/classes/BatchStatus.d.ts

@@ -1,19 +1,19 @@
 import { ENTRY_STATUS } from '../constants';
-import { PromiseInterface } from '../interfaces';
+import { PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } from '../models';
-import { EntryStatus, ItemEntryEntryStatusMap, ItemId } from '../types';
+import { EntryStatus, ItemEntryEntryStatusMap, ItemId, PromiseInterface } from '../types';
 export declare class BatchStatus {
     private promiseService;
     getItemId: (itemEntry: ItemEntry) => ItemId;
-    getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>;
+    getPromise: (itemEntry: ItemEntry) => PromiseInterface<ItemEntry>;
     readonly requestStatusArray: ENTRY_STATUS[];
     entries: ItemEntryEntryStatusMap;
-    constructor(promiseService: PromiseInterface, getItemId: (itemEntry: ItemEntry) => ItemId, getPromise: (itemEntry: ItemEntry) => Promise<ItemEntry>);
+    constructor(promiseService: PromiseLibraryInterface, getItemId: (itemEntry: ItemEntry) => ItemId, getPromise: (itemEntry: ItemEntry) => PromiseInterface<ItemEntry>);
     add(entryStatus: EntryStatus<ItemEntry>): void;
     hasEntries(statusArray: ENTRY_STATUS[]): boolean;
     hasRequests(): boolean;
     forEachEntry(statusArray: ENTRY_STATUS[], callback: (itemEntry: ItemEntry) => void): void;
-    getPromises(): Promise<ItemEntry[]>;
+    getPromises(): PromiseInterface<ItemEntry[]>;
     getRequestIds(): number[];
     getArray(): ItemEntry[];
 }

package/dist/{dist → src}/classes/ChangesProcessor.d.ts

@@ -1,8 +1,8 @@
 import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler } from '../classes';
 import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, ItemEntry } from '../models';
-import { CreateRequestParameterMap, ItemIdConversionMap } from '../types';
+import { CreateRequestParameterMap, ItemIdConversionMap, PromiseInterface } from '../types';
 export declare class ChangesProcessor {
     private apiRequestService;
     private itemHandler;
@@ -15,7 +15,7 @@ export declare class ChangesProcessor {
     private collectionEntryService;
     private apiFormatter;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseInterface);
+    constructor(apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, errorHandler: ErrorHandlerInterface, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseLibraryInterface);
     getItemTypeUpdatePriority(itemType: any): 0 | 1 | 2;
     isDocumentItemType(itemType: any): boolean;
     isDocumentUpdate(compilation: any): boolean;
@@ -33,5 +33,5 @@ export declare class ChangesProcessor {
     private addCollectionMapEntry(collectionMap, parentId, itemEntry, value);
     private forEachCollection(collectionMap, method);
     private onItemsCreated(conversionMap, singleItems, collections);
-    execute(singleItems: ItemEntry[], collections: CollectionEntry[], parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): Promise<ItemIdConversionMap>;
+    execute(singleItems: ItemEntry[], collections: CollectionEntry[], parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
 }

package/dist/{dist → src}/classes/CollectionHandler.d.ts

@@ -1,7 +1,8 @@
+import { PromiseInterface } from '../';
 import { CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemRequestService, KeyService, QueryService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemResource } from '../models';
 import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, RequestColumn } from '../types';
 export declare class CollectionHandler {
@@ -18,7 +19,7 @@ export declare class CollectionHandler {
     private queryService;
     private collectionMatcherFactory;
     entries: CollectionCache;
-    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, collectionMatcherFactory: CollectionMatcherFactory);
+    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService, collectionMatcherFactory: CollectionMatcherFactory);
     getPromises(statusResource: CollectionEntryBatchStatusMap): CollectionEntry[];
     getRequestIds(statusResource: any): number[];
     /**
@@ -34,11 +35,11 @@ export declare class CollectionHandler {
      * @deprecated, use collectionMatcherFactory
      */
     addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
-    batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: RequestColumn[]): Promise<CollectionResource[]>;
-    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): Promise<ItemResourceItemIdMap>;
-    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
+    batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: RequestColumn[]): PromiseInterface<CollectionResource[]>;
+    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): PromiseInterface<ItemResourceItemIdMap>;
+    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntryParentIdMap>;
     createStatusResource(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: any, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
-    fetch(itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntry>;
+    fetch(itemType: ItemType, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry>;
     getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
     getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
         entry: CollectionEntry;
@@ -50,7 +51,7 @@ export declare class CollectionHandler {
         columnExpansion?: ColumnExpansion;
         items?: ItemEntryParentIdMap;
     }, itemCache: ItemCache): CollectionEntryParentIdMap;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): Promise<CollectionEntry>;
-    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): Promise<CollectionEntry>;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
+    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     isLocal(options: any): boolean;
 }

package/dist/{dist → src}/classes/ColumnHandler.d.ts

@@ -1,21 +1,21 @@
 import { ColumnCache, ColumnUtil } from '../classes';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { ItemType, RequestColumns, ResponseColumn, ResponseColumnMap } from '../types';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemType, PromiseInterface, RequestColumns, ResponseColumn, ResponseColumnMap } from '../types';
 export declare class ColumnHandler {
     private apiRequestService;
     private errorHandler;
     private promiseService;
     private cache;
     private columnUtil;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseInterface, cache: ColumnCache, columnUtil: ColumnUtil);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, cache: ColumnCache, columnUtil: ColumnUtil);
     setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
     setColumns(itemType: ItemType, requestColumns: RequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
-    fetchItemTypeTranslations(itemTypes: ItemType[]): Promise<{
+    fetchItemTypeTranslations(itemTypes: ItemType[]): PromiseInterface<{
         [itemType: string]: string;
     }>;
     request(itemType: ItemType, columns: RequestColumns, params?: {
         filter: boolean;
-    }): Promise<ResponseColumnMap>;
-    fetch(itemType: ItemType, requestColumns: RequestColumns, params?: any): Promise<ResponseColumnMap>;
-    fetchAll(itemType: ItemType): Promise<ResponseColumnMap>;
+    }): PromiseInterface<ResponseColumnMap>;
+    fetch(itemType: ItemType, requestColumns: RequestColumns, params?: any): PromiseInterface<ResponseColumnMap>;
+    fetchAll(itemType: ItemType): PromiseInterface<ResponseColumnMap>;
 }

package/dist/{dist → src}/classes/ItemAdministrator.d.ts

@@ -1,8 +1,8 @@
 import { CollectionCache, CollectionEntryService, CollectionHandler, CollectionMatcher, CollectionResourceService, ItemCache, ItemEntryService, ItemHandler, ItemRequestService, KeyService, LocalCache, QueryService } from '../classes';
 import { CollectionMatcherFactory, ColumnSetFactory, LocalCacheFactory, ModuleChangesCompilationFactory } from '../factories';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseInterface } from '../interfaces';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptions, ItemResourceItemTypeMap, ItemType, LocalCacheCallbackCondition, OnSaveCallback, TemplateItemEntryMap, TemplateLinkedItemEntryMap } from '../types';
+import { CollectionResourceParentIdMap, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemOptions, ItemResourceItemTypeMap, ItemType, LocalCacheCallbackCondition, OnSaveCallback, PromiseInterface, TemplateItemResourceMap, TemplateLinkedItemEntryMap } from '../types';
 export declare class ItemAdministrator {
     private apiRequestService;
     private authInterface;
@@ -21,13 +21,13 @@ export declare class ItemAdministrator {
     private moduleChangesCompilationFactory;
     private promiseInterface;
     private queryService;
-    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceService: CollectionResourceService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseInterface, queryService: QueryService);
+    constructor(apiRequestService: ApiRequestServiceInterface, authInterface: AuthInterface, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, collectionResourceService: CollectionResourceService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, localCacheFactory: LocalCacheFactory, localCacheManager: LocalCacheManagerInterface, moduleChangesCompilationFactory: ModuleChangesCompilationFactory, promiseInterface: PromiseLibraryInterface, queryService: QueryService);
     invalidateCache(): void;
     getCollectionMatcher(itemEntries: ItemEntry[], addToTab: boolean): CollectionMatcher;
-    fetchTitle(itemType: any, itemId: any, deferRequest: any): Promise<any>;
-    getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptions, isRoot?: boolean): Promise<ItemResource>;
-    getItemsById(itemType: string, itemIds: number[], options: any): Promise<ItemResource[]>;
-    getItemsByQuery(itemType: string, query: any, options: any): Promise<ItemResource[]>;
+    fetchTitle(itemType: any, itemId: any, deferRequest: any): PromiseInterface<string>;
+    getItemById(itemType: ItemType, itemId: ItemId, options: ItemOptions, isRoot?: boolean): PromiseInterface<ItemResource>;
+    getItemsById(itemType: string, itemIds: number[], options: any): PromiseInterface<ItemResource[]>;
+    getItemsByQuery(itemType: string, query: any, options: any): PromiseInterface<ItemResource[]>;
     /**
      * The return value is depended on the return links boolean. true returns the TemplateResponseItemEntryMap.
      * The type has to be asserted at use since you only know the type of the return value when the function is called
@@ -36,11 +36,11 @@ export declare class ItemAdministrator {
      * @param options
      * @param {boolean} returnLinks
      * @param {boolean} isRoot
-     * @returns {Promise<ItemResource | TemplateItemEntryMap>}
+     * @returns {PromiseInterface<ItemResource | TemplateItemEntryMap>}
      */
-    getNewResource(itemType: ItemType, options?: ItemOptions, returnLinks?: boolean, isRoot?: boolean): Promise<ItemResource | TemplateItemEntryMap>;
-    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options?: ItemOptions, returnLinks?: boolean, isRoot?: boolean): Promise<ItemResource | TemplateItemEntryMap>;
-    getItemByState(itemType: ItemType, stateKey: ItemId | string, options?: ItemOptions, isRoot?: boolean): Promise<ItemResource>;
+    getNewResource(itemType: ItemType, options?: ItemOptions, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
+    getDuplicateById(itemType: ItemType, duplicateId: ItemId, options?: ItemOptions, returnLinks?: boolean, isRoot?: boolean): PromiseInterface<ItemResource | TemplateItemResourceMap>;
+    getItemByState(itemType: ItemType, stateKey: ItemId | string, options?: ItemOptions, isRoot?: boolean): PromiseInterface<ItemResource>;
     getCollectionDef(itemType: string, options: any): {
         itemType: string;
         options: {
@@ -58,15 +58,15 @@ export declare class ItemAdministrator {
             resource: any;
         };
     };
-    getCollection(itemType: string, options: any): Promise<CollectionResource>;
-    getCollectionFromDef(definition: any): Promise<CollectionResource>;
+    getCollection(itemType: string, options: any): PromiseInterface<CollectionResource>;
+    getCollectionFromDef(definition: any): PromiseInterface<CollectionResource>;
     /**
      * @deprecated, use `parent` in options
      */
-    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): Promise<CollectionResource>;
-    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): Promise<CollectionResourceParentIdMap>;
-    getLinkCollectionsFromDef(definition: any): Promise<CollectionResourceParentIdMap>;
-    getAllLinkCollections(linkType: string, itemType: string, options: any): Promise<CollectionEntryParentIdMap>;
+    getLinkCollection(linkType: string, linkId: number, itemType: string, options: any): PromiseInterface<CollectionResource>;
+    getLinkCollections(linkType: string, linkIdArray: number[], itemType: string, options: any): PromiseInterface<CollectionResourceParentIdMap>;
+    getLinkCollectionsFromDef(definition: any): PromiseInterface<CollectionResourceParentIdMap>;
+    getAllLinkCollections(linkType: string, itemType: string, options: any): PromiseInterface<CollectionResourceParentIdMap>;
     cloneItem(itemResource: ItemResource, options: any): ItemResource;
     cloneCollection(collectionResource: CollectionResource, options: any, conversionMap: any): CollectionResource;
     saveCurrentLocalCache(closeTab?: boolean, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): any;
@@ -85,7 +85,7 @@ export declare class ItemAdministrator {
     resetLocalCache(): void;
     addToCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
     removeFromCollections(itemEntries: ItemEntry[], resultCollectionResource?: CollectionResource): ItemResource[] | null;
-    saveLocal(itemResource: ItemResource): Promise<ItemResource>;
+    saveLocal(itemResource: ItemResource): PromiseInterface<ItemResource>;
     updateItemIdMap(collectionMap: any, conversionMap: any): void;
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: any, processOptions?: boolean): CollectionResource;
     createItemResource(itemEntry: ItemEntry, options: any, isRoot: boolean): ItemResource;

package/dist/{dist → src}/classes/ItemHandler.d.ts

@@ -1,9 +1,9 @@
 import { ApiFormatter, ApiResponseProcessor, BatchStatus, ColumnExpansion, ColumnHandler, ColumnInfo, ColumnSet, ColumnUtil, ItemCache, ItemEntryService, KeyService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, ColumnExpansionFactory, ColumnSetFactory, ItemCacheFactory, ItemEntryFactory, TemplateFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, Template } from '../models';
-import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemOptions, ItemType, RequestColumns, TemplateItemEntryMap, TemplateLinkedItemEntryMap } from '../types';
+import { ApiResponse, EntryStatus, FieldMap, ItemId, ItemIdConversionMap, ItemOptions, ItemType, PromiseInterface, RequestColumns, TemplateItemEntryMap, TemplateLinkedItemEntryMap } from '../types';
 export declare class ItemHandler {
     private apiFormatter;
     private apiRequestService;
@@ -23,21 +23,21 @@ export declare class ItemHandler {
     templates: {
         [itemType: string]: Template;
     };
-    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface, templateFactory: TemplateFactory);
-    fetchItem(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): Promise<ItemEntry>;
-    fetchNewItem(itemType: ItemType, options: ItemOptions, localItemCache: ItemCache): Promise<TemplateItemEntryMap>;
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, batchStatusFactory: BatchStatusFactory, columnExpansionFactory: ColumnExpansionFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, errorHandler: ErrorHandlerInterface, itemCacheFactory: ItemCacheFactory, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseLibraryInterface, templateFactory: TemplateFactory);
+    fetchItem(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): PromiseInterface<ItemEntry>;
+    fetchNewItem(itemType: ItemType, options: ItemOptions, localItemCache: ItemCache): PromiseInterface<TemplateItemEntryMap>;
     /**
      *
      * @param itemType
      * @param itemIds
      * @param options
-     * @returns {Promise<ItemEntry[]>}
+     * @returns {PromiseInterface<ItemEntry[]>}
      *
      * For every itemid find the status of the ItemEntry and resolve the promises so the result is
      * a usable ItemEntry
      */
-    fetchItems(itemType: ItemType, itemIds: ItemId[], options: any, localItemCache: ItemCache): Promise<ItemEntry[]>;
-    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): Promise<ItemEntry>;
+    fetchItems(itemType: ItemType, itemIds: ItemId[], options: any, localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
+    resolveCached(itemEntry: ItemEntry, status: ENTRY_STATUS, options: any): PromiseInterface<ItemEntry>;
     resolveLocal(itemEntry: ItemEntry, parent: any, template: any, localItemCache: ItemCache): TemplateItemEntryMap;
     resolveExpansion(itemEntry: ItemEntry, columnExpansion: ColumnExpansion, response: ApiResponse): ItemEntry;
     resolveRemote(itemEntry: ItemEntry, columnSet: ColumnSet, response: ApiResponse): ItemEntry | null;
@@ -46,7 +46,7 @@ export declare class ItemHandler {
         initial: FieldMap;
         derived: FieldMap;
     } | null;
-    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): Promise<Template>;
+    fetchTemplate(itemType: string, templateOptions?: any, templateColumns?: any): PromiseInterface<Template>;
     getEntryStatus(itemType: ItemType, itemId: ItemId, options: any, localItemCache: ItemCache): EntryStatus<ItemEntry> | null;
     isColumnSuperset(itemEntry: ItemEntry, columns: RequestColumns): any;
     getCachedEntryStatus(itemEntry: ItemEntry, options: any): ENTRY_STATUS;
@@ -64,13 +64,13 @@ export declare class ItemHandler {
     batchResolve(itemType: ItemType, batchStatus: BatchStatus, requestColumns: RequestColumns, resolved: {
         entries: ItemEntry[];
         requests?: ApiResponseProcessor;
-    }): ItemEntry[] | Promise<any>;
+    }): ItemEntry[] | PromiseInterface<any>;
     createLocalEntries(parentType: ItemType, localParentId: ItemId, template: any, itemIdConversion: ItemIdConversionMap, localItemCache: ItemCache, excludeItemTypes?: ItemType[]): TemplateLinkedItemEntryMap[];
-    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): Promise<any>;
-    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): Promise<ItemEntry[]>;
+    fetchTitle(itemType: ItemType, itemId: ItemId, deferRequest: boolean | undefined, localItemCache: ItemCache): PromiseInterface<string>;
+    resolveDerivedValues(itemEntries: ItemEntry[], columns: ColumnInfo[], localItemCache: ItemCache): PromiseInterface<ItemEntry[]>;
     private getDefaultValuesByColumn(itemEntries, rootColumn);
     private getItemIdByColumn(itemEntry, column);
     private fetchDerivedValuesByColumn(itemEntries, rootColumn, localItemCache);
-    requestItem(itemEntry: ItemEntry, requestColumns?: RequestColumns): Promise<ApiResponseProcessor>;
-    requestItems(itemType: ItemType, itemIds: ItemId[], columns: RequestColumns): Promise<ApiResponseProcessor>;
+    requestItem(itemEntry: ItemEntry, requestColumns?: RequestColumns): PromiseInterface<ApiResponseProcessor>;
+    requestItems(itemType: ItemType, itemIds: ItemId[], columns: RequestColumns): PromiseInterface<ApiResponseProcessor>;
 }

package/dist/{dist → src}/classes/ItemRequestService.d.ts

@@ -1,8 +1,8 @@
 import { ApiResponseProcessor, ColumnExpansion, ColumnSet, ItemHandler, QueryService } from '../classes';
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, ItemEntry } from '../models';
-import { ApiResponse, EntryParentNull, ItemId, ItemType, RequestColumns } from '../types';
+import { ApiResponse, EntryParentNull, ItemId, ItemType, PromiseInterface, RequestColumns } from '../types';
 export declare class ItemRequestService {
     private apiRequestService;
     private errorHandler;
@@ -12,12 +12,12 @@ export declare class ItemRequestService {
     private itemEntryFactory;
     private queryService;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseInterface);
-    requestItem(itemType: any, itemId: any, columns: any): Promise<ApiResponseProcessor>;
-    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): Promise<ApiResponseProcessor>;
-    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): Promise<ApiResponseProcessor>;
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, columnExpansionFactory: ColumnExpansionFactory, columnSetFactory: ColumnSetFactory, itemEntryFactory: ItemEntryFactory, queryService: QueryService, promiseService: PromiseLibraryInterface);
+    requestItem(itemType: any, itemId: any, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestItems(collectionEntry: CollectionEntry, query?: any, columns?: any): PromiseInterface<ApiResponseProcessor>;
+    requestLinkItems(parentType: any, parentIdArray: any, itemType: any, query: any, columns: any): PromiseInterface<ApiResponseProcessor>;
     processExpansion(requestColumns: RequestColumns, response: ApiResponse, itemType: ItemType, itemEntries: ItemEntry[]): ColumnExpansion;
-    processResponse(response: ApiResponse, idArray: ItemId[], parent: EntryParentNull, columnSet: ColumnSet, columnExpansion?: ColumnExpansion): Promise<ItemEntry[]>;
+    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/{dist → src}/classes/LocalCache.d.ts

@@ -1,8 +1,8 @@
 import { CollectionCache, ItemCache, ItemResourceService, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
-import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptions, OnSaveCallback, LocalCacheCallbackCondition } from '../types';
+import { CollectionEntryParentIdMap, CreateRequestParameterMap, ItemIdConversionMap, ItemOptions, LocalCacheCallbackCondition, OnSaveCallback } from '../types';
 export declare class LocalCache {
     private errorHandler;
     private lockService;
@@ -22,7 +22,7 @@ export declare class LocalCache {
     private callbacks;
     private changesInterval;
     hasChanges: boolean;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseInterface, id?: string);
+    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseLibraryInterface, id?: string);
     createItemResource(itemEntry: ItemEntry, options: ItemOptions, isRoot?: boolean, isNew?: boolean): ItemResource;
     createItemResources(itemEntries: ItemEntry[], options: ItemOptions): ItemResource[];
     createCollectionResource(collectionEntry: CollectionEntry, resourceOptions: any): CollectionResource;

package/dist/{dist → src}/classes/LockService.d.ts

@@ -1,5 +1,5 @@
 import { KeyService } from '../classes';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry } from '../models';
 export declare class LockService {
     private apiRequestService;
@@ -8,7 +8,7 @@ export declare class LockService {
     private promiseService;
     lockItems: {};
     promises: {};
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseInterface);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
     getValue(itemEntry: ItemEntry, map: any): any;
     setValue(itemEntry: ItemEntry, value: any, map: any): any;
     getLocks(): {};

package/dist/{dist → src}/classes/SocketMessageHandler.d.ts

@@ -1,7 +1,7 @@
 import { ApiFormatter, CollectionHandler, ItemHandler } from '../classes';
 import { ColumnExpansionFactory, ColumnSetFactory, ItemEntryFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { CollectionMatchResult, FieldMap } from '../types';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionMatchResult, FieldMap, GroupedExtendedCollectionMatchResult, PromiseInterface } from '../types';
 export declare class SocketMessageHandler {
     private promiseService;
     private apiRequestService;
@@ -13,20 +13,20 @@ export declare class SocketMessageHandler {
     private requestColumnExpansionFactory;
     private apiFormatter;
     private errorHandler;
-    constructor(promiseService: PromiseInterface, apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, itemEntryFactory: ItemEntryFactory, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface);
+    constructor(promiseService: PromiseLibraryInterface, apiRequestService: ApiRequestServiceInterface, itemHandler: ItemHandler, itemEntryFactory: ItemEntryFactory, collectionHandler: CollectionHandler, columnSetFactory: ColumnSetFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface);
     onMessageReceived(message: any): any;
     formatMessageValues(values: any, columns: any): FieldMap;
     createCollectionMap(itemType: any, items: any, columns: any): {
         [itemId: number]: CollectionMatchResult;
     };
-    groupByCollectionId(itemType: any, collectionMap: any): {};
+    groupByCollectionId(itemType: any, collectionMap: any): GroupedExtendedCollectionMatchResult;
     getRequestColumns(itemType: any, collectionMap: any): {};
     deferEntry(itemEntry: any): any;
-    processMessage(body: any): Promise<any>;
+    processMessage(body: any): PromiseInterface<GroupedExtendedCollectionMatchResult>;
     processFunctionChangesResolve(body: any): Promise<any> | undefined;
-    handleResponse(itemType: any, requestIds: any, requestColumns: any, response: any, collectionMap: any): {};
+    handleResponse(itemType: any, requestIds: any, requestColumns: any, response: any, collectionMap: any): GroupedExtendedCollectionMatchResult;
     handleCreate(message: any): Promise<any> | undefined;
     handleUpdate(message: any): Promise<any>;
-    handleDelete(message: any): Promise<{}>;
+    handleDelete(message: any): PromiseInterface<{}>;
     handleLinkMove(): void;
 }

package/dist/{dist/main.d.ts → src/core.d.ts}

@@ -1,6 +1,6 @@
 import { ApiFormatter, ApiRequestService, CollectionEntryService, CollectionHandler, CollectionResourceService, ColumnCache, ColumnHandler, ColumnUtil, ItemAdministrator, ItemEntryService, ItemHandler, ItemRequestService, ItemResourceService, KeyService, LockService, QueryService, SocketMessageHandler } from './classes';
 import { ApiResponseProcessorFactory, BatchStatusFactory, ChangesCompilationFactory, ChangesProcessorFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, CollectionResourceFactory, ColumnExpansionFactory, ColumnInfoFactory, ColumnSetFactory, CreateRequestFactory, ItemCacheFactory, ItemEntryFactory, ItemResourceFactory, LocalCacheFactory, ModuleChangesCompilationFactory, QueryMatcherFactory, QueryParserFactory, RequestColumnExpansionFactory, TemplateFactory } from './factories';
-import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseInterface } from './interfaces';
+import { ApiRequestServiceInterface, AuthInterface, ErrorHandlerInterface, LocalCacheManagerInterface, PromiseLibraryInterface } from './interfaces';
 export declare class RmCore {
     version: string;
     noop: typeof noop;
@@ -42,7 +42,7 @@ export declare class RmCore {
     requestColumnExpansionFactory: RequestColumnExpansionFactory;
     socketMessageHandler: SocketMessageHandler;
     templateFactory: TemplateFactory;
-    constructor(externalApiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface, promiseInterface: PromiseInterface);
+    constructor(externalApiRequestService: ApiRequestServiceInterface, localCacheManager: LocalCacheManagerInterface, authInterface: AuthInterface, errorHandlerInterface: ErrorHandlerInterface, promiseLibraryInterface: PromiseLibraryInterface);
 }
 export declare function noop(): void;
 export declare function identity(value: any): any;

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

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

package/dist/{dist → src}/factories/ChangesProcessorFactory.d.ts

@@ -1,6 +1,6 @@
 import { ApiFormatter, ChangesProcessor, CollectionEntryService, CollectionHandler, ItemHandler } from '../classes';
 import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class ChangesProcessorFactory {
     private apiRequestService;
     private errorHandler;
@@ -13,6 +13,6 @@ export declare class ChangesProcessorFactory {
     private collectionEntryService;
     private apiFormatter;
     private promiseService;
-    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseInterface);
+    constructor(apiRequestService: ApiRequestServiceInterface, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, collectionHandler: CollectionHandler, changesCompilationFactory: ChangesCompilationFactory, createRequestFactory: CreateRequestFactory, columnExpansionFactory: ColumnExpansionFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, apiFormatter: ApiFormatter, promiseService: PromiseLibraryInterface);
     construct(): ChangesProcessor;
 }

package/dist/{dist → src}/factories/CollectionEntryFactory.d.ts

@@ -1,6 +1,6 @@
 import { CollectionEntryService, ItemEntryService, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
 import { ColumnSetFactory, ItemEntryFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry } from '../models/';
 export declare class CollectionEntryFactory {
     collectionEntryService: CollectionEntryService;
@@ -11,8 +11,8 @@ export declare class CollectionEntryFactory {
     itemHandler: ItemHandler;
     itemRequestService: ItemRequestService;
     keyService: KeyService;
-    promiseService: PromiseInterface;
+    promiseService: PromiseLibraryInterface;
     queryService: QueryService;
-    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService);
+    constructor(collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemEntryFactory: ItemEntryFactory, itemEntryService: ItemEntryService, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryService: QueryService);
     construct(itemType: string, options: any): CollectionEntry;
 }

package/dist/{dist → src}/factories/CollectionResourceFactory.d.ts

@@ -1,14 +1,14 @@
 import { CollectionResourceService, KeyService, LocalCache } from '../classes';
 import { ChangesProcessorFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { CollectionEntry, CollectionResource } from '../models';
 export declare class CollectionResourceFactory {
     errorHandler: ErrorHandlerInterface;
     itemResourceFactory: ItemResourceFactory;
     changesProcessorFactory: ChangesProcessorFactory;
     keyService: KeyService;
-    promiseService: PromiseInterface;
+    promiseService: PromiseLibraryInterface;
     collectionResourceService: CollectionResourceService;
-    constructor(errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseInterface, collectionResourceService: CollectionResourceService);
+    constructor(errorHandler: ErrorHandlerInterface, itemResourceFactory: ItemResourceFactory, changesProcessorFactory: ChangesProcessorFactory, keyService: KeyService, promiseService: PromiseLibraryInterface, collectionResourceService: CollectionResourceService);
     construct(collectionEntry: CollectionEntry, options: any, localCache: LocalCache): CollectionResource;
 }

package/dist/{dist → src}/factories/ItemEntryFactory.d.ts

@@ -1,6 +1,6 @@
 import { ApiFormatter, ColumnSet, ItemEntryService, KeyService } from '../classes';
 import { ColumnSetFactory } from '../factories';
-import { AuthInterface, PromiseInterface } from '../interfaces';
+import { AuthInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, Template } from '../models';
 import { EntryParentNull, FieldMap, ItemId, ItemIdConversionMap, ItemType, RequestColumns } from '../types';
 export declare class ItemEntryFactory {
@@ -9,8 +9,8 @@ export declare class ItemEntryFactory {
     columnSetFactory: ColumnSetFactory;
     itemEntryService: ItemEntryService;
     keyService: KeyService;
-    promiseService: PromiseInterface;
-    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface);
+    promiseService: PromiseLibraryInterface;
+    constructor(authInterface: AuthInterface, apiFormatter: ApiFormatter, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, 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?: any): ItemEntry;

package/dist/{dist → src}/factories/ItemResourceFactory.d.ts

@@ -1,5 +1,5 @@
 import { ApiFormatter, ChangesProcessor, ItemResourceService, LockService } from '../classes';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { ItemEntry, ItemResource } from '../models';
 import { ItemOptions } from '../types';
 export declare class ItemResourceFactory {
@@ -8,8 +8,8 @@ export declare class ItemResourceFactory {
     lockService: LockService;
     changesProcessor: ChangesProcessor;
     errorHandler: ErrorHandlerInterface;
-    promiseService: PromiseInterface;
-    constructor(itemResourceService: ItemResourceService, apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseInterface);
+    promiseService: PromiseLibraryInterface;
+    constructor(itemResourceService: ItemResourceService, apiFormatter: ApiFormatter, lockService: LockService, changesProcessor: ChangesProcessor, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface);
     getConstructor(options: ItemOptions): (itemEntry: ItemEntry) => ItemResource;
     construct(itemEntry: ItemEntry, options: ItemOptions, isNew?: boolean): ItemResource;
 }

package/dist/{dist → src}/factories/LocalCacheFactory.d.ts

@@ -1,6 +1,6 @@
 import { ItemResourceService, LocalCache, LockService } from '../classes';
 import { ChangesProcessorFactory, CollectionCacheFactory, CollectionResourceFactory, ItemCacheFactory, ItemResourceFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 export declare class LocalCacheFactory {
     private errorHandler;
     private lockService;
@@ -11,6 +11,6 @@ export declare class LocalCacheFactory {
     private collectionResourceFactory;
     private itemResourceService;
     private promiseService;
-    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseInterface);
+    constructor(errorHandler: ErrorHandlerInterface, lockService: LockService, itemResourceFactory: ItemResourceFactory, collectionCacheFactory: CollectionCacheFactory, changesProcessorFactory: ChangesProcessorFactory, itemCacheFactory: ItemCacheFactory, collectionResourceFactory: CollectionResourceFactory, itemResourceService: ItemResourceService, promiseService: PromiseLibraryInterface);
     construct(id?: string): LocalCache;
 }

package/dist/{dist → src}/index.d.ts

@@ -1,4 +1,4 @@
-export * from './main';
+export * from './core';
 export * from './constants';
 export * from './models';
 export * from './interfaces';

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

@@ -0,0 +1,11 @@
+import { ItemId, ItemType, PromiseInterface } from '../types';
+export interface ApiRequestServiceInterface {
+    template(itemType: string, 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: object, columns: any): PromiseInterface<any>;
+    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<any>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: object): PromiseInterface<any>;
+    columns(itemType: ItemType, columns: object, params?: any): PromiseInterface<any>;
+    query(itemType: ItemType, query: object, columns: object, limit?: object): PromiseInterface<any>;
+}

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

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