@rentman/rm-core 1.7.2 → 1.7.4

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

@@ -7,15 +7,15 @@ export declare class ApiFormatter {
     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;
+    formatResponse(fields: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    expandResponse(current: FieldMap, expanded: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    formatRequest(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    formatRequestLocal(fields: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): boolean;
+    getChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    copyFields(source: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
     compareFields(columnType: string, first?: any, second?: any): boolean;
     compareFloats(a: number, b: number): boolean;
     compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;

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

@@ -19,21 +19,19 @@ export declare class ApiResponseProcessor {
     fetchValue(itemType: ItemType, itemId: ItemId, columnId: string): any;
     fetchDerivedObject(itemType: ItemType, itemId: ItemId, rootColumns: ResponseColumn[]): {};
     fetchDerivedValues(value: any, column: ResponseColumn, destination: any): void;
-    fetchObject(itemType: ItemType, itemId: string | ItemId, includeLinks?: boolean): any;
-    fetchObjectArray(itemType: ItemType, includeLinks?: boolean, idArray?: ItemId[] | null): FieldMap[];
+    fetchObject<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId, includeLinks?: boolean): FieldMap<ItemTypeType> | undefined;
+    fetchObjectArray<ItemTypeType extends ItemType>(itemType: ItemTypeType, includeLinks?: boolean, idArray?: ItemId[] | null): Array<FieldMap<ItemTypeType>>;
     fetchObjectMap(itemType: ItemType, columnId: string, includeLinks?: boolean, returnKeys?: boolean): {
         [key: string]: any;
     };
-    fetchFieldMap(itemType: ItemType, columnId: string): {
-        [itemId: number]: FieldMap;
-    };
+    fetchFieldMap<ItemTypeType extends ItemType>(itemType: ItemTypeType, columnId: string): FieldMap<ItemTypeType>;
     fetchColumnArray(itemType: ItemType): ResponseColumn[];
     fetchColumnObject(itemType: ItemType): ResponseColumn;
     fetchColumnsObject(): {
         [itemType: string]: ResponseColumn;
     };
-    createResource(itemType: ItemType, id: ItemId): {
-        object: FieldMap;
+    createResource<ItemTypeType extends ItemType>(itemType: ItemTypeType, id: ItemId): {
+        object: FieldMap<ItemTypeType> | undefined;
         links: any;
     };
     hasItems(itemType: ItemType): boolean;

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

@@ -1,16 +1,17 @@
 import { ENTRY_STATUS } from '../constants';
 import { PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, ItemEntry } from '../models';
 import { EntryStatus, EntryStatusMap, ItemId, ItemType, PromiseInterface } from '../types';
-export declare class BatchStatus<T> {
+export declare class BatchStatus<ItemTypeType extends ItemType, T extends ItemEntry<ItemTypeType> | CollectionEntry<ItemTypeType>> {
     private promiseService;
-    itemType: ItemType;
+    itemType: ItemTypeType;
     getItemId: (itemEntry: T) => ItemId;
     getPromise: (itemEntry: T) => PromiseInterface<T>;
     readonly requestStatus: ENTRY_STATUS[];
     readonly remoteExpandStatus: ENTRY_STATUS[];
     readonly localExpandStatus: ENTRY_STATUS[];
     entries: EntryStatusMap<T>;
-    constructor(promiseService: PromiseLibraryInterface, itemType: ItemType, getItemId: (itemEntry: T) => ItemId, getPromise: (itemEntry: T) => PromiseInterface<T>);
+    constructor(promiseService: PromiseLibraryInterface, itemType: ItemTypeType, getItemId: (itemEntry: T) => ItemId, getPromise: (itemEntry: T) => PromiseInterface<T>);
     add(entryStatus: EntryStatus<T>): void;
     hasEntries(statusArray: ENTRY_STATUS[]): boolean;
     hasRequests(): boolean;

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

@@ -2,32 +2,32 @@ 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 DeleteMapEntry = {
-    item: ItemEntry;
+export declare type DeleteMapEntry<ItemTypeType extends ItemType> = {
+    item: ItemEntry<ItemTypeType>;
     parent: EntryParentNull;
 };
-export declare type MoveMapEntry = {
-    item: ItemEntry;
+export declare type MoveMapEntry<ItemTypeType extends ItemType> = {
+    item: ItemEntry<ItemTypeType>;
     parent: EntryParent;
 };
 export declare type CreateCompilation = {
     [parentType: string]: {
-        [parentId: number]: ItemEntryMap;
+        [parentId: number]: ItemEntryMap<ItemType>;
     };
 };
 export declare type DeleteCompilation = {
-    [itemType: string]: ItemEntry[];
+    [itemType: string]: Array<ItemEntry<ItemType>>;
 };
-export declare type UpdateCompilation = ItemEntryMap;
+export declare type UpdateCompilation = ItemEntryMap<ItemType>;
 export declare type MoveCompilation = {
     [parentType: string]: {
-        [parentId: number]: MoveMapEntry[];
+        [parentId: number]: Array<MoveMapEntry<any>>;
     };
 };
 export declare class ChangesCompilation {
     private collectionCacheFactory;
     private keyService;
-    singleItems: ItemEntry[];
+    singleItems: Array<ItemEntry<ItemType>>;
     compilation: {
         create: CreateCompilation;
         delete: DeleteCompilation;
@@ -37,12 +37,12 @@ export declare class ChangesCompilation {
     collections: CollectionCache;
     private moveArray;
     private deleteMap;
-    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService, singleItems: ItemEntry[], collectionEntries: CollectionEntry[]);
+    constructor(collectionCacheFactory: CollectionCacheFactory, keyService: KeyService, singleItems: Array<ItemEntry<ItemType>>, collectionEntries: Array<CollectionEntry<ItemType>>);
     getDefaultParent(): EntryParent;
-    addMoveEntry(itemEntry: ItemEntry): void;
-    addDeleteEntry(itemEntry: ItemEntry, parent: EntryParentNull): void;
-    addUpdateEntry(itemEntry: ItemEntry): void;
-    addCreateEntry(itemEntry: ItemEntry): void;
+    addMoveEntry(itemEntry: ItemEntry<ItemType>): void;
+    addDeleteEntry(itemEntry: ItemEntry<ItemType>, parent: EntryParentNull): void;
+    addUpdateEntry(itemEntry: ItemEntry<ItemType>): void;
+    addCreateEntry(itemEntry: ItemEntry<ItemType>): void;
     containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
     private createDeleteCompilation;
     postProcess(): void;

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

@@ -16,7 +16,7 @@ export declare class ChangesProcessor {
     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: MoveMapEntry[]): ApiRequestMoveItems;
+    buildMoveRequest(compilationEntries: Array<MoveMapEntry<any>>): ApiRequestMoveItems;
     getMapValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
     private executeCreateRequests;
     private executeCreateRequest;
@@ -29,5 +29,5 @@ export declare class ChangesProcessor {
     private addCollectionMapEntry;
     private forEachCollection;
     private onItemsCreated;
-    execute(singleItems: ItemEntry[], collections: CollectionEntry[], parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
+    execute(singleItems: Array<ItemEntry<any>>, collections: Array<CollectionEntry<any>>, parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
 }

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

@@ -6,29 +6,29 @@ export declare class CollectionCache {
     private queryMatcherFactory;
     private entries;
     constructor(collectionResourceFactory: CollectionResourceFactory, 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: ItemId): boolean;
-    getByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): CollectionEntry | null;
-    getResourceByParent(parentType: ItemType, parentId: ItemId, itemType: ItemType): CollectionResource | null;
-    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry[];
+    contains(collectionEntry: CollectionEntry<any>): boolean;
+    some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
+    forEach(callback: (entry: CollectionEntry<any>) => void): void;
+    toArray(): CollectionEntry<any>[];
+    add<T extends CollectionEntry<any>>(collectionEntry: T): T;
+    clear(collectionEntry?: CollectionEntry<any>): boolean;
+    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): CollectionEntry<ItemTypeType>[];
+    matchParent(collectionEntry: CollectionEntry<any>, itemType: string, itemId: ItemId): boolean;
+    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionEntry<ItemTypeType> | null;
+    getResourceByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionResource<ItemTypeType> | null;
+    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry<any>[];
     /**
      * Only resources
      * @param {String} itemType
      * @param {String|Integer} itemId
      * @returns {Object} Array of collections.
      */
-    getByContainingItem(itemType: ItemType, itemId: ItemId): CollectionEntry[];
+    getByContainingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId): CollectionEntry<ItemTypeType>[];
     /**
      * Returns an array of collections the item 'belongs' in.
      */
-    getByFittingItem(itemType: ItemType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult;
-    getByQuery(itemType: ItemType, query: CollectionQuery): CollectionEntry | null;
-    getByKey(itemType: ItemType, entryKey: string): CollectionEntry[];
-    getResourceByKey(itemType: ItemType, resourceKey: string): CollectionResource[];
+    getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
+    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
+    getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
+    getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
 }

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

@@ -1,16 +1,16 @@
 import { QueryService } from '../classes';
 import { QueryParserFactory } from '../factories';
 import { CollectionEntryOptions, ItemEntry } from '../models';
-import { CollectionOptionsInterface, CollectionQuery, EntryParentNull, ItemId } from '../types';
+import { CollectionOptionsInterface, CollectionQuery, EntryParentNull, ItemId, ItemType } from '../types';
 export declare class CollectionEntryService {
     private queryParserFactory;
     private queryService;
     constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
     cloneOptions(options: CollectionEntryOptions, parent: EntryParentNull): CollectionEntryOptions;
-    processOptions(options: CollectionOptionsInterface): CollectionEntryOptions;
+    processOptions<ItemTypeType extends ItemType>(options: CollectionOptionsInterface<ItemTypeType>): CollectionEntryOptions;
     cloneQueryParams<T extends object>(parameters: T): T;
     createQuery(options: CollectionEntryOptions): CollectionQuery;
-    getIdArray(itemEntries: ItemEntry[], accumulator?: ItemId[]): ItemId[];
+    getIdArray(itemEntries: Array<ItemEntry<any>>, accumulator?: ItemId[]): ItemId[];
     /**
      * @param {ItemEntry[]} itemEntries
      * @param {(itemEntry: ItemEntry) => boolean} callback
@@ -19,5 +19,5 @@ export declare class CollectionEntryService {
      * 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[];
+    filterArray<T extends ItemEntry<any> = ItemEntry<any>>(itemEntries: T[], callback: (itemEntry: T) => boolean): T[];
 }

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

@@ -25,30 +25,30 @@ export declare class CollectionHandler {
      * @deprecated, use collectionMatcherFactory
      */
     removeFromAndAddToCollections(collectionMap: any): void;
-    getCollectionMatcher(): CollectionMatcher;
+    getCollectionMatcher<ItemTypeType extends ItemType>(): CollectionMatcher<ItemTypeType>;
     /**
      * @deprecated, use collectionMatcherFactory
      */
-    removeFromCollections<T extends CollectionResource = CollectionViewResource>(collectionMap: any, updateInitial?: boolean, resultResource?: T | null): T['items'] | null;
+    removeFromCollections<T extends CollectionResource<any> = CollectionViewResource<any>>(collectionMap: any, updateInitial?: boolean, resultResource?: T | null): T['items'] | null;
     /**
      * @deprecated, use collectionMatcherFactory
      */
-    addToCollections<T extends CollectionResource = CollectionViewResource>(collectionMap: any, updateInitial: boolean, resultResource?: T | null): T['items'];
-    batchExpand(parentType: ItemType, itemType: ItemType, collections: CollectionResourceParentIdMap, newColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    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(parentType: ItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntryParentIdMap>;
-    handleBatchResponse(batchStatus: BatchStatus<CollectionEntry>, itemEntryCompound: {
-        columns: ColumnSet;
-        columnExpansion?: ColumnExpansion;
-        items?: ItemEntryParentIdMap;
-    }, localItems: ItemEntryParentIdMap): CollectionEntryParentIdMap;
-    fetch(itemType: ItemType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): PromiseInterface<CollectionEntry>;
+    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(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
-    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
+    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/CollectionMatcher.d.ts

@@ -1,19 +1,19 @@
-import { ItemId } from '../';
+import { ItemId, ItemType } from '../';
 import { CollectionCache } from '../classes';
 import { QueryMatcherFactory } from '../factories/';
 import { CollectionEntry, CollectionResource, ItemEntry } from '../models';
-export declare type CollectionMatcherMatches = {
+export declare type CollectionMatcherMatches<ItemTypeType extends ItemType> = {
     [itemId: number]: {
-        item: ItemEntry;
+        item: ItemEntry<ItemTypeType>;
         isMatch: boolean | 'maybe';
     };
 };
-export declare type GroupedCollectionMatcherResult = {
-    fitting: ItemEntry[];
+export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
+    fitting: Array<ItemEntry<ItemTypeType>>;
     notFitting: ItemId[];
-    maybe: ItemEntry[];
+    maybe: Array<ItemEntry<ItemTypeType>>;
 };
-export declare class CollectionMatcher {
+export declare class CollectionMatcher<ItemTypeType extends ItemType> {
     private queryMatcherFactory;
     private collectionCaches;
     private updateInitial;
@@ -21,20 +21,20 @@ export declare class CollectionMatcher {
     private callOnActivate;
     map: {
         [collectionEntryId: number]: {
-            collection: CollectionEntry;
-            matches: CollectionMatcherMatches;
+            collection: CollectionEntry<ItemTypeType>;
+            matches: CollectionMatcherMatches<ItemTypeType>;
         };
     };
     constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean);
-    expand(itemEntry: ItemEntry): this;
+    expand(itemEntry: ItemEntry<ItemTypeType>): this;
     private _expand;
-    getCollectionsWithFittingItems(): CollectionEntry[];
-    addToCollections<U extends CollectionResource>(resultResource: U): U['items'];
+    getCollectionsWithFittingItems(): Array<CollectionEntry<ItemTypeType>>;
+    addToCollections<U extends CollectionResource<ItemTypeType>>(resultResource: U): U['items'];
     addToCollections(resultResource?: null): null;
-    addToCollections<U extends CollectionResource>(resultResource?: CollectionResource | null): U['items'] | null;
-    removeFromCollections<U extends CollectionResource>(resultResource: U): U['items'];
+    addToCollections<U extends CollectionResource<ItemTypeType>>(resultResource?: CollectionResource<ItemTypeType> | null): U['items'] | null;
+    removeFromCollections<U extends CollectionResource<ItemTypeType>>(resultResource: U): U['items'];
     removeFromCollections(resultResource?: null): null;
-    removeFromCollections<U extends CollectionResource>(resultResource?: CollectionResource | null): U['items'] | null;
+    removeFromCollections<U extends CollectionResource<ItemTypeType>>(resultResource?: CollectionResource<ItemTypeType> | null): U['items'] | null;
     removeFromAndAddToCollections(): void;
     private groupItemEntries;
     private groupItemIds;

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

@@ -1,6 +1,6 @@
 import { CollectionResourceOptions, CollectionResourceOptionsInterface, ItemResource } from '../models';
-import { ItemId } from '../types';
+import { ItemId, ItemType } from '../types';
 export declare class CollectionResourceService {
-    processOptions(options: CollectionResourceOptionsInterface): CollectionResourceOptions;
-    getIdArray(itemResources: ItemResource[]): ItemId[];
+    processOptions<ItemTypeType extends ItemType>(options: CollectionResourceOptionsInterface<ItemTypeType>): CollectionResourceOptions<ItemTypeType>;
+    getIdArray(itemResources: Array<ItemResource<any>>): ItemId[];
 }

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

@@ -1,18 +1,18 @@
 import { ColumnInfo, ColumnSet } from '../classes';
 import { ColumnInfoFactory } from '../factories';
 import { ApiRequestColumn, ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
-export declare class ColumnExpansion {
+export declare class ColumnExpansion<ItemTypeType extends ItemType> {
     private columnInfoFactory;
-    itemType: ItemType;
+    itemType: ItemTypeType;
     responseColumns: ResponseColumnMap;
     expansionMap: {
-        [columnSetId: string]: ColumnExpansionResult | null;
+        [columnSetId: string]: ColumnExpansionResult<ItemTypeType> | null;
     };
     expansionMapSize: number;
     requestColumnsTrue: boolean;
     requestColumns: ApiRequestColumn[];
-    constructor(columnInfoFactory: ColumnInfoFactory, itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap);
-    run(columnSet: ColumnSet): ColumnExpansionResult | null;
-    aggregateRootColumns(): ColumnInfo[];
+    constructor(columnInfoFactory: ColumnInfoFactory, itemType: ItemTypeType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap);
+    run(columnSet: ColumnSet<ItemTypeType>): ColumnExpansionResult<ItemTypeType> | null;
+    aggregateRootColumns(): Array<ColumnInfo<ItemTypeType>>;
     private expandRootColumnMap;
 }

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

@@ -1,14 +1,14 @@
 import { ItemType, ResponseColumn } from '../types';
-export declare class ColumnInfo {
+export declare class ColumnInfo<ItemTypeType extends ItemType = any> {
     readonly apiColumn: ResponseColumn;
-    readonly parent: ColumnInfo | null;
+    readonly parent: ColumnInfo<ItemType> | null;
     id: string;
     level: number;
     path: string;
     tailPath: string;
-    itemType: ItemType | null;
-    children: ColumnInfo[];
+    itemType: ItemTypeType | null;
+    children: Array<ColumnInfo<ItemTypeType>>;
     isLeaf: boolean;
-    constructor(apiColumn: ResponseColumn, parent?: ColumnInfo | null);
-    setChildren(itemType: ItemType, children: ColumnInfo[]): this;
+    constructor(apiColumn: ResponseColumn, parent?: ColumnInfo<ItemType> | null);
+    setChildren(itemType: ItemTypeType, children: Array<ColumnInfo<ItemTypeType>>): this;
 }

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

@@ -1,31 +1,31 @@
 import { ColumnHandler, ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
 import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
 import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
-export declare class ColumnSet {
+export declare class ColumnSet<ItemTypeType extends ItemType = any> {
     private columnHandler;
     private columnUtil;
     private columnInfoFactory;
     private columnSetFactory;
-    itemType: ItemType;
+    itemType: ItemTypeType;
     request: ApiRequestColumns;
     id: number;
     requestColumnsTrue: boolean;
     response: ResponseColumnMap;
-    link: ColumnInfo | null;
-    main: ColumnInfo[];
-    derived: ColumnInfo[];
-    root: ColumnInfo[];
-    leaf: ColumnInfo[];
+    link: ColumnInfo<ItemTypeType> | null;
+    main: Array<ColumnInfo<ItemTypeType>>;
+    derived: Array<ColumnInfo<ItemTypeType>>;
+    root: Array<ColumnInfo<ItemTypeType>>;
+    leaf: Array<ColumnInfo<ItemTypeType>>;
     formatted: {
-        main: ColumnInfo[];
-        derived: ColumnInfo[];
+        main: Array<ColumnInfo<ItemTypeType>>;
+        derived: Array<ColumnInfo<ItemTypeType>>;
     };
-    filtered: ColumnInfo[];
-    custom: ColumnInfo[];
-    searchable: ColumnInfo[];
-    item: ColumnInfo[];
-    notItem: ColumnInfo[];
-    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: ItemType, request: ApiRequestColumns);
+    filtered: Array<ColumnInfo<ItemTypeType>>;
+    custom: Array<ColumnInfo<ItemTypeType>>;
+    searchable: Array<ColumnInfo<ItemTypeType>>;
+    item: Array<ColumnInfo<ItemTypeType>>;
+    notItem: Array<ColumnInfo<ItemTypeType>>;
+    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: ItemTypeType, request: ApiRequestColumns);
     toJSON(): {
         main: string[];
         derived: string[];
@@ -41,6 +41,6 @@ export declare class ColumnSet {
     private getMergedColumnSet;
     mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
     mergeResponseColumns(responseColumns: ResponseColumnMap): ResponseColumnMap;
-    merge(columnSet: ColumnSet): ColumnSet;
-    expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
+    merge(columnSet: ColumnSet<ItemTypeType>): ColumnSet<ItemTypeType>;
+    expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult<ItemTypeType>;
 }

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

@@ -1,8 +1,8 @@
 import { ColumnSet } from '../classes';
-import { ApiRequestColumns } from '../types';
-export declare class ColumnSubsetCache {
+import { ApiRequestColumns, ItemType } from '../types';
+export declare class ColumnSubsetCache<ItemTypeType extends ItemType> {
     requestColumns: ApiRequestColumns;
     private cache;
     constructor(requestColumns: ApiRequestColumns);
-    run(columnSet: ColumnSet): boolean;
+    run(columnSet: ColumnSet<ItemTypeType>): boolean;
 }

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

@@ -1,7 +1,7 @@
 import { CollectionCache, CollectionHandler, CreateCompilation, KeyService } from '../classes';
 import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
 import { CreateRequestEntry, CreateRequestParameterMap, ItemType } from '../types';
-export declare class CreateRequest {
+export declare class CreateRequest<ItemTypeType extends ItemType> {
     private collectionHandler;
     private collectionMatcherFactory;
     private keyService;
@@ -10,11 +10,11 @@ export declare class CreateRequest {
     private localCollectionCache;
     private parameterMap;
     private breakupByParent;
-    requests: CreateRequestEntry[];
+    requests: Array<CreateRequestEntry<ItemTypeType>>;
     constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, localCollectionCache: CollectionCache, parameterMap: CreateRequestParameterMap, breakupByParent?: boolean);
-    finalizeRequest(requestResource: CreateRequestEntry): CreateRequestEntry;
-    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry): boolean;
-    run(): CreateRequestEntry[];
-    initializeRequest(): CreateRequestEntry;
+    finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
+    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
+    run(): CreateRequestEntry<ItemTypeType>[];
+    initializeRequest(): CreateRequestEntry<ItemTypeType>;
     private extendRequest;
 }