@rentman/rm-core 1.3.5 → 1.3.7

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

@@ -1,40 +1,40 @@
-/// <reference types="moment" />
-import * as moment from 'moment';
-import { FieldMap } from '../types';
-import { ColumnInfo } from './ColumnInfo';
-export declare class ApiFormatter {
-    MOMENT_INVALID: string;
-    SERVER_DATETIME_FORMAT: string;
-    SERVER_TIME_FORMAT: string;
-    SERVER_DATE_FORMAT: string;
-    constructor();
-    formatResponse(fields: FieldMap, columns: ColumnInfo[]): FieldMap;
-    expandResponse(current: FieldMap, expanded: FieldMap, columns: ColumnInfo[]): FieldMap;
-    formatRequest(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): FieldMap;
-    formatRequestLocal(fields: FieldMap, columns: ColumnInfo[]): FieldMap;
-    hasChanges(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): boolean;
-    getChanges(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): FieldMap;
-    copyFields(source: FieldMap, destination: FieldMap, columns: ColumnInfo[]): FieldMap;
-    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: ColumnInfo[]): FieldMap;
-    setDefaultValues(destination: FieldMap, columns: ColumnInfo[]): FieldMap;
-    compareFields<T>(columnType: string, first: T, second: T): boolean;
-    compareFloats(a: any, b: any): boolean;
-    compareMomentObjects(first: any, second: any): boolean;
-    compareDurations(first: any, second: any): boolean;
-    formatResponseValue(columnType: any, value: any): any;
-    formatRequestValue(columnType: any, value: any): any;
-    formatResponseDate(value: any): moment.Moment;
-    formatResponseDuration(value: any): moment.Duration;
-    formatResponseColor(value: any): any;
-    formatRequestDateTime(value: any): any;
-    formatRequestDate(value: any): any;
-    formatRequestDuration(value: any): any;
-    formatRequestColor(value: any): any;
-    getDefaultValue(columnType: any): false | 0 | "" | moment.Moment | moment.Duration | "0" | "#000000" | null;
-    isDefaultValue(columnType: any, value: any): boolean;
-    clone(columnType: any, value: any): any;
-    getCloneFunction(columnType: any): (date: any) => any;
-    cloneDuration(duration: any): moment.Duration;
-    cloneDate(date: any): any;
-    identity(input: any): any;
-}
+/// <reference types="moment" />
+import * as moment from 'moment';
+import { FieldMap } from '../types';
+import { ColumnInfo } from './ColumnInfo';
+export declare class ApiFormatter {
+    MOMENT_INVALID: string;
+    SERVER_DATETIME_FORMAT: string;
+    SERVER_TIME_FORMAT: string;
+    SERVER_DATE_FORMAT: string;
+    constructor();
+    formatResponse(fields: FieldMap, columns: ColumnInfo[]): FieldMap;
+    expandResponse(current: FieldMap, expanded: FieldMap, columns: ColumnInfo[]): FieldMap;
+    formatRequest(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): FieldMap;
+    formatRequestLocal(fields: FieldMap, columns: ColumnInfo[]): FieldMap;
+    hasChanges(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): boolean;
+    getChanges(initial: FieldMap, modified: FieldMap, columns: ColumnInfo[]): FieldMap;
+    copyFields(source: FieldMap, destination: FieldMap, columns: ColumnInfo[]): FieldMap;
+    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: ColumnInfo[]): FieldMap;
+    setDefaultValues(destination: FieldMap, columns: ColumnInfo[]): FieldMap;
+    compareFields<T>(columnType: string, first: T, second: T): boolean;
+    compareFloats(a: any, b: any): boolean;
+    compareMomentObjects(first: any, second: any): boolean;
+    compareDurations(first: any, second: any): boolean;
+    formatResponseValue(columnType: any, value: any): any;
+    formatRequestValue(columnType: any, value: any): any;
+    formatResponseDate(value: any): moment.Moment;
+    formatResponseDuration(value: any): moment.Duration;
+    formatResponseColor(value: any): any;
+    formatRequestDateTime(value: any): any;
+    formatRequestDate(value: any): any;
+    formatRequestDuration(value: any): any;
+    formatRequestColor(value: any): any;
+    getDefaultValue(columnType: any): false | "" | 0 | moment.Moment | moment.Duration | "0" | "#000000" | null;
+    isDefaultValue(columnType: any, value: any): boolean;
+    clone(columnType: any, value: any): any;
+    getCloneFunction(columnType: any): (date: any) => any;
+    cloneDuration(duration: any): moment.Duration;
+    cloneDate(date: any): any;
+    identity(input: any): any;
+}

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

@@ -1,18 +1,20 @@
-import { ApiResponseProcessor } from '../classes';
-import { ApiResponseProcessorFactory } from '../factories';
-import { ApiRequestServiceInterface } from '../interfaces';
-import { ItemId, ItemType, PromiseInterface } from '../types';
-export declare class ApiRequestService {
-    private externalApiRequestService;
-    private apiResponseProcessorFactory;
-    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    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>;
-}
+import { ApiResponseProcessor } from '../classes';
+import { ApiResponseProcessorFactory } from '../factories';
+import { ApiRequestServiceInterface } from '../interfaces';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ItemId, ItemType, PromiseInterface } from '../types';
+export declare class ApiRequestService {
+    private externalApiRequestService;
+    private apiResponseProcessorFactory;
+    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
+    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: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
+    moveItems(parentType: ItemType, parentId: ItemId, items: {
+        [itemType: string]: ItemId[];
+    }): PromiseInterface<ApiResponseProcessor>;
+    columns(itemType: ItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
+    query(itemType: ItemType, query: any, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
+    processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
+}

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

@@ -1,33 +1,33 @@
-import { ApiFormatter } from '../classes';
-import { ItemTypeMap } from '../types';
-export declare class ApiResponseProcessor {
-    apiFormatter: ApiFormatter;
-    response: any;
-    columns: ItemTypeMap;
-    items: ItemTypeMap;
-    links: ItemTypeMap;
-    cacheable: boolean;
-    map: any;
-    columnIndexMap: any;
-    columnMap: any;
-    constructor(apiFormatter: ApiFormatter, response: any);
-    createColumnMaps(): void;
-    fetchValue(itemType: any, itemId: any, columnId: any): any;
-    fetchDerivedObject(itemType: any, itemId: any, rootColumns: any): {};
-    fetchDerivedValues(value: any, column: any, destination: any): void;
-    fetchObject(itemType: any, itemId: any, includeLinks?: boolean): any;
-    fetchObjectArray(itemType: any, includeLinks: any, idArray: any): any;
-    fetchObjectMap(itemType: any, columnId: any, includeLinks: any, returnKeys: any): {
-        [key: string]: any;
-    };
-    fetchFieldMap(itemType: any, columnId: any): {};
-    fetchColumnArray(itemType: any): any[];
-    fetchColumnObject(itemType: any): any;
-    fetchColumnsObject(): any;
-    createResource(itemType: any, id: any): {
-        object: any;
-        links: any;
-    };
-    hasItems(itemType: any): boolean;
-    getIdArray(itemType: any): string[];
-}
+import { ApiFormatter } from '../classes';
+import { ItemTypeMap } from '../types';
+export declare class ApiResponseProcessor {
+    apiFormatter: ApiFormatter;
+    response: any;
+    columns: ItemTypeMap;
+    items: ItemTypeMap;
+    links: ItemTypeMap;
+    cacheable: boolean;
+    map: any;
+    columnIndexMap: any;
+    columnMap: any;
+    constructor(apiFormatter: ApiFormatter, response: any);
+    createColumnMaps(): void;
+    fetchValue(itemType: any, itemId: any, columnId: any): any;
+    fetchDerivedObject(itemType: any, itemId: any, rootColumns: any): {};
+    fetchDerivedValues(value: any, column: any, destination: any): void;
+    fetchObject(itemType: any, itemId: any, includeLinks?: boolean): any;
+    fetchObjectArray(itemType: any, includeLinks: any, idArray: any): any;
+    fetchObjectMap(itemType: any, columnId: any, includeLinks: any, returnKeys: any): {
+        [key: string]: any;
+    };
+    fetchFieldMap(itemType: any, columnId: any): {};
+    fetchColumnArray(itemType: any): any[];
+    fetchColumnObject(itemType: any): any;
+    fetchColumnsObject(): any;
+    createResource(itemType: any, id: any): {
+        object: any;
+        links: any;
+    };
+    hasItems(itemType: any): boolean;
+    getIdArray(itemType: any): string[];
+}

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

@@ -1,19 +1,19 @@
-import { ENTRY_STATUS } from '../constants';
-import { PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { EntryStatus, ItemEntryEntryStatusMap, ItemId, PromiseInterface } from '../types';
-export declare class BatchStatus {
-    private promiseService;
-    getItemId: (itemEntry: ItemEntry) => ItemId;
-    getPromise: (itemEntry: ItemEntry) => PromiseInterface<ItemEntry>;
-    readonly requestStatusArray: ENTRY_STATUS[];
-    entries: ItemEntryEntryStatusMap;
-    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(): PromiseInterface<ItemEntry[]>;
-    getRequestIds(): number[];
-    getArray(): ItemEntry[];
-}
+import { ENTRY_STATUS } from '../constants';
+import { PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry } from '../models';
+import { EntryStatus, ItemEntryEntryStatusMap, ItemId, PromiseInterface } from '../types';
+export declare class BatchStatus {
+    private promiseService;
+    getItemId: (itemEntry: ItemEntry) => ItemId;
+    getPromise: (itemEntry: ItemEntry) => PromiseInterface<ItemEntry>;
+    readonly requestStatusArray: ENTRY_STATUS[];
+    entries: ItemEntryEntryStatusMap;
+    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(): PromiseInterface<ItemEntry[]>;
+    getRequestIds(): number[];
+    getArray(): ItemEntry[];
+}

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

@@ -1,26 +1,43 @@
-import { CollectionCache } from '../classes';
-import { CollectionCacheFactory } from '../factories';
-import { CollectionEntry, ItemEntry } from '../models';
-import { EntryParent } from '../types';
-export declare class ChangesCompilation {
-    private collectionCacheFactory;
-    singleItems: ItemEntry[];
-    compilation: {
-        create: {};
-        delete: {};
-        update: {};
-        move: {};
-    };
-    collections: CollectionCache;
-    private moveArray;
-    private deleteMap;
-    constructor(collectionCacheFactory: CollectionCacheFactory, singleItems: ItemEntry[], collectionEntries: CollectionEntry[]);
-    getDefaultParent(): EntryParent;
-    addMoveEntry(itemEntry: any): void;
-    addDeleteEntry(itemEntry: any, parentId: any, parentType: any): void;
-    addUpdateEntry(itemEntry: any): void;
-    addCreateEntry(itemEntry: any): void;
-    postProcess(): void;
-    private processSingleItems();
-    private processCollections(collectionEntries);
-}
+import { CollectionCache, KeyService } from '../classes';
+import { CollectionCacheFactory } from '../factories';
+import { CollectionEntry, ItemEntry } from '../models';
+import { EntryParent, EntryParentNull, ItemEntryMap, ItemId, ItemType } from '../types';
+export declare type CreateCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemEntryMap;
+    };
+};
+export declare type DeleteCompilation = {
+    [itemType: string]: ItemEntry[];
+};
+export declare type UpdateCompilation = ItemEntryMap;
+export declare type MoveCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemEntry[];
+    };
+};
+export declare class ChangesCompilation {
+    private collectionCacheFactory;
+    private keyService;
+    singleItems: ItemEntry[];
+    compilation: {
+        create: CreateCompilation;
+        delete: DeleteCompilation;
+        update: UpdateCompilation;
+        move: MoveCompilation;
+    };
+    collections: CollectionCache;
+    private moveArray;
+    private deleteMap;
+    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService, singleItems: ItemEntry[], collectionEntries: CollectionEntry[]);
+    getDefaultParent(): EntryParent;
+    addMoveEntry(itemEntry: ItemEntry): void;
+    addDeleteEntry(itemEntry: ItemEntry, parent: EntryParentNull): void;
+    addUpdateEntry(itemEntry: ItemEntry): void;
+    addCreateEntry(itemEntry: ItemEntry): void;
+    containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
+    private createDeleteCompilation();
+    postProcess(): void;
+    private processSingleItems();
+    private processCollections(collectionEntries);
+}

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

@@ -1,37 +1,33 @@
-import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler } from '../classes';
-import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, ItemEntry } from '../models';
-import { CreateRequestParameterMap, ItemIdConversionMap, PromiseInterface } from '../types';
-export declare class ChangesProcessor {
-    private apiRequestService;
-    private itemHandler;
-    private errorHandler;
-    private collectionHandler;
-    private changesCompilationFactory;
-    private createRequestFactory;
-    private columnExpansionFactory;
-    private requestColumnExpansionFactory;
-    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: PromiseLibraryInterface);
-    getItemTypeUpdatePriority(itemType: any): 0 | 1 | 2;
-    isDocumentItemType(itemType: any): boolean;
-    isDocumentUpdate(compilation: any): boolean;
-    buildMoveRequest(compilationEntries: any): {};
-    getMapValue(itemType: any, itemId: any, map: any): any;
-    private executeCreateRequests(changesCompilation, parameters, conversionMap, breakupByParent?, onAfterCreateCallback?);
-    private executeCreateRequest(requestResource, conversionMap);
-    private prioritizeUpdateRequests(compilation, parameters);
-    private executeUpdateRequests(itemTypes, compilation, parameters);
-    private executeUpdateRequest(itemType, itemEntries, parameterMap);
-    private executeDeleteRequests(compilation);
-    private executeDeleteRequest(itemType, itemEntries);
-    private executeMoveRequests(compilation, conversionMap);
-    private processMoveResponse(compilationEntries);
-    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): PromiseInterface<ItemIdConversionMap>;
-}
+import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler } from '../classes';
+import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
+import { CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
+export declare class ChangesProcessor {
+    private apiFormatter;
+    private apiRequestService;
+    private changesCompilationFactory;
+    private collectionEntryService;
+    private collectionHandler;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private itemHandler;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    constructor(apiFormatter: ApiFormatter, apiRequestService: ApiRequestServiceInterface, changesCompilationFactory: ChangesCompilationFactory, collectionEntryService: CollectionEntryService, collectionHandler: CollectionHandler, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory);
+    buildMoveRequest(compilationEntries: any): {};
+    getMapValue(itemType: ItemType, itemId: number | string, map: ItemIdConversionMap): ItemId | undefined;
+    private executeCreateRequests(changesCompilation, parameters, conversionMap, breakupByParent?, onAfterCreateCallback?);
+    private executeCreateRequest(requestResource, conversionMap);
+    private executeUpdateRequests(compilation, parameters);
+    private executeUpdateRequest(itemType, itemEntries, parameterMap);
+    private executeDeleteRequests(compilation);
+    private executeDeleteRequest(itemType, itemEntries);
+    private executeMoveRequests(compilation, conversionMap);
+    private processMoveResponse(compilationEntries);
+    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): PromiseInterface<ItemIdConversionMap>;
+}

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

@@ -1,37 +1,37 @@
-import { QueryMatcherFactory } from '../factories';
-import { CollectionEntry, CollectionResource } from '../models';
-import { CollectionMatchResult, EntryParentNull, FieldMap, ItemType } from '../types';
-export declare class CollectionCache {
-    private queryMatcherFactory;
-    entries: {
-        [itemType: string]: {
-            [collectionEntryId: number]: CollectionEntry;
-        };
-    };
-    constructor(queryMatcherFactory: QueryMatcherFactory);
-    contains(collectionEntry: CollectionEntry): boolean;
-    some(callback: (entry: CollectionEntry) => boolean): boolean;
-    forEach(callback: (entry: CollectionEntry) => void): void;
-    toArray(): CollectionEntry[];
-    add(collectionEntry: CollectionEntry): CollectionEntry;
-    clear(collectionEntry?: CollectionEntry): boolean;
-    getByItemType(itemType: string): CollectionEntry[];
-    matchParent(collectionEntry: CollectionEntry, itemType: string, itemId: any): boolean;
-    getByParent(parentType: any, parentId: any, itemType: any): CollectionEntry | null;
-    getResourceByParent(parentType: any, parentId: any, itemType: any): CollectionResource | null;
-    getCollectionsByParent(parentType: any, parentId: any): CollectionEntry[];
-    /**
-     * Only resources
-     * @param {String} itemType
-     * @param {String|Integer} itemId
-     * @returns {Object} Array of collections.
-     */
-    getByContainingItem(itemType: any, itemId: any): CollectionEntry[];
-    /**
-     * Returns an array of collections the item 'belongs' in.
-     */
-    getByFittingItem(itemType: ItemType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult;
-    getByQuery(itemType: any, query: any): CollectionEntry | null;
-    getByKey(itemType: any, entryKey: any): CollectionEntry[];
-    getResourceByKey(itemType: any, resourceKey: any): CollectionResource[];
-}
+import { QueryMatcherFactory } from '../factories';
+import { CollectionEntry, CollectionResource } from '../models';
+import { CollectionMatchResult, EntryParentNull, FieldMap, ItemType } from '../types';
+export declare class CollectionCache {
+    private queryMatcherFactory;
+    entries: {
+        [itemType: string]: {
+            [collectionEntryId: number]: CollectionEntry;
+        };
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory);
+    contains(collectionEntry: CollectionEntry): boolean;
+    some(callback: (entry: CollectionEntry) => boolean): boolean;
+    forEach(callback: (entry: CollectionEntry) => void): void;
+    toArray(): CollectionEntry[];
+    add(collectionEntry: CollectionEntry): CollectionEntry;
+    clear(collectionEntry?: CollectionEntry): boolean;
+    getByItemType(itemType: string): CollectionEntry[];
+    matchParent(collectionEntry: CollectionEntry, itemType: string, itemId: any): boolean;
+    getByParent(parentType: any, parentId: any, itemType: any): CollectionEntry | null;
+    getResourceByParent(parentType: any, parentId: any, itemType: any): CollectionResource | null;
+    getCollectionsByParent(parentType: any, parentId: any): CollectionEntry[];
+    /**
+     * Only resources
+     * @param {String} itemType
+     * @param {String|Integer} itemId
+     * @returns {Object} Array of collections.
+     */
+    getByContainingItem(itemType: any, itemId: any): CollectionEntry[];
+    /**
+     * Returns an array of collections the item 'belongs' in.
+     */
+    getByFittingItem(itemType: ItemType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult;
+    getByQuery(itemType: any, query: any): CollectionEntry | null;
+    getByKey(itemType: any, entryKey: any): CollectionEntry[];
+    getResourceByKey(itemType: any, resourceKey: any): CollectionResource[];
+}

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

@@ -1,26 +1,26 @@
-import { QueryService } from '../classes';
-import { QueryParserFactory } from '../factories';
-import { ItemEntry } from '../models';
-import { ItemId } from '../types';
-export declare class CollectionEntryService {
-    private queryParserFactory;
-    private queryService;
-    constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
-    cloneOptions(options: any, parent: any): any;
-    cloneQueryParams(parameters: any): {};
-    processOptions(options: any): any;
-    createQuery(options: any): {
-        object: any;
-        string: any;
-    };
-    getIdArray(itemEntries: ItemEntry[], accumulator: any): ItemId[];
-    /**
-     * @param {ItemEntry[]} itemEntries
-     * @param {(itemEntry: ItemEntry) => boolean} callback
-     * @returns {ItemEntry[]}
-     *
-     * filter an array according to the callback function. Return the entries that failed the condition
-     * Replace the given array with the entries that didn't fail the condition.
-     */
-    filterArray(itemEntries: ItemEntry[], callback: (itemEntry: ItemEntry) => boolean): ItemEntry[];
-}
+import { QueryService } from '../classes';
+import { QueryParserFactory } from '../factories';
+import { ItemEntry } from '../models';
+import { ItemId } from '../types';
+export declare class CollectionEntryService {
+    private queryParserFactory;
+    private queryService;
+    constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
+    cloneOptions(options: any, parent: any): any;
+    cloneQueryParams(parameters: any): {};
+    processOptions(options: any): any;
+    createQuery(options: any): {
+        object: any;
+        string: any;
+    };
+    getIdArray(itemEntries: ItemEntry[], accumulator: any): ItemId[];
+    /**
+     * @param {ItemEntry[]} itemEntries
+     * @param {(itemEntry: ItemEntry) => boolean} callback
+     * @returns {ItemEntry[]}
+     *
+     * filter an array according to the callback function. Return the entries that failed the condition
+     * Replace the given array with the entries that didn't fail the condition.
+     */
+    filterArray(itemEntries: ItemEntry[], callback: (itemEntry: ItemEntry) => boolean): ItemEntry[];
+}

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

@@ -1,57 +1,57 @@
-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, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, ItemResource } from '../models';
-import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, RequestColumn } from '../types';
-export declare class CollectionHandler {
-    private errorHandler;
-    private itemRequestService;
-    private columnHandler;
-    private columnSetFactory;
-    private collectionEntryFactory;
-    private collectionCacheFactory;
-    private queryParserFactory;
-    private collectionEntryService;
-    private keyService;
-    private promiseService;
-    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: PromiseLibraryInterface, queryService: QueryService, collectionMatcherFactory: CollectionMatcherFactory);
-    getPromises(statusResource: CollectionEntryBatchStatusMap): CollectionEntry[];
-    getRequestIds(statusResource: any): number[];
-    /**
-     * @deprecated, use collectionMatcherFactory
-     */
-    removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
-    getCollectionMatcher(): CollectionMatcher;
-    /**
-     * @deprecated, use collectionMatcherFactory
-     */
-    removeFromCollections(collectionMap: any, updateInitial?: any, resultResource?: CollectionResource | null): any;
-    /**
-     * @deprecated, use collectionMatcherFactory
-     */
-    addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
-    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): PromiseInterface<CollectionEntry>;
-    getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
-    getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
-        entry: CollectionEntry;
-        isDeferred: boolean;
-    };
-    getEntryStatus(itemType: ItemType, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
-    handleBatchResponse(statusResource: any, itemEntryCompound: {
-        columns: ColumnSet;
-        columnExpansion?: ColumnExpansion;
-        items?: ItemEntryParentIdMap;
-    }, itemCache: ItemCache): CollectionEntryParentIdMap;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
-    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
-    isLocal(options: any): boolean;
-}
+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, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource, ItemResource } from '../models';
+import { ApiRequestColumn, CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType } from '../types';
+export declare class CollectionHandler {
+    private errorHandler;
+    private itemRequestService;
+    private columnHandler;
+    private columnSetFactory;
+    private collectionEntryFactory;
+    private collectionCacheFactory;
+    private queryParserFactory;
+    private collectionEntryService;
+    private keyService;
+    private promiseService;
+    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: PromiseLibraryInterface, queryService: QueryService, collectionMatcherFactory: CollectionMatcherFactory);
+    getPromises(statusResource: CollectionEntryBatchStatusMap): CollectionEntry[];
+    getRequestIds(statusResource: any): number[];
+    /**
+     * @deprecated, use collectionMatcherFactory
+     */
+    removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
+    getCollectionMatcher(): CollectionMatcher;
+    /**
+     * @deprecated, use collectionMatcherFactory
+     */
+    removeFromCollections(collectionMap: any, updateInitial?: any, resultResource?: CollectionResource | null): any;
+    /**
+     * @deprecated, use collectionMatcherFactory
+     */
+    addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
+    batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResource[], newColumns: ApiRequestColumn[]): 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): PromiseInterface<CollectionEntry>;
+    getCachedEntryStatus(collectionEntry: CollectionEntry, options: any): ENTRY_STATUS;
+    getDeferredEntryStatus(itemType: ItemType, options: any, query: any, deferredEntries: CollectionCache): {
+        entry: CollectionEntry;
+        isDeferred: boolean;
+    };
+    getEntryStatus(itemType: ItemType, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
+    handleBatchResponse(statusResource: any, itemEntryCompound: {
+        columns: ColumnSet;
+        columnExpansion?: ColumnExpansion;
+        items?: ItemEntryParentIdMap;
+    }, itemCache: ItemCache): CollectionEntryParentIdMap;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
+    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
+    isLocal(options: any): boolean;
+}