@rentman/rm-core 1.0.33 → 1.1.0

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

@@ -1,23 +1,26 @@
-import { QueryParserFactory } from "../factories";
-import { ItemEntry } from "../models";
-import { QueryService } from './QueryService';
-export declare class CollectionEntryService {
-    private queryParserFactory;
-    private queryService;
-    constructor(queryParserFactory: QueryParserFactory, queryService: QueryService);
-    processOptions(options: any): any;
-    createQuery(options: any): {
-        object: any;
-        string: any;
-    };
-    getIdArray(itemEntries: ItemEntry[], accumulator: any): number[];
-    /**
-     * @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/dist/classes/CollectionHandler.d.ts

@@ -1,64 +1,49 @@
-import { CollectionCacheFactory, CollectionEntryFactory, ColumnSetFactory, QueryParserFactory } from "../factories";
-import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from "../models";
-import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemResourceItemIdMap } from '../types/ItemTypesCollection';
-import { CollectionCache } from "./CollectionCache";
-import { CollectionEntryService } from "./CollectionEntryService";
-import { ColumnHandler } from "./ColumnHandler";
-import { ColumnUtil } from "./ColumnUtil";
-import { ItemCache } from "./ItemCache";
-import { ItemEntryService } from "./ItemEntryService";
-import { ItemHandler } from "./ItemHandler";
-import { ItemRequestService } from "./ItemRequestService";
-import { KeyService } from "./KeyService";
-import { QueryService } from "./QueryService";
-export declare class CollectionHandler {
-    private errorHandler;
-    private itemRequestService;
-    private itemHandler;
-    private columnHandler;
-    private collectionEntryFactory;
-    private collectionCacheFactory;
-    private queryParserFactory;
-    private collectionEntryService;
-    private columnSetFactory;
-    private itemEntryService;
-    private keyService;
-    private promiseService;
-    private queryService;
-    private columnUtil;
-    entries: CollectionCache;
-    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, itemHandler: ItemHandler, columnHandler: ColumnHandler, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, itemEntryService: ItemEntryService, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, columnUtil: ColumnUtil);
-    getPromises(statusResource: CollectionEntryBatchStatusMap): any[];
-    getRequestIds(statusResource: any): any[];
-    removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
-    removeFromCollections(collectionMap: any, updateInitial?: any, resultResource?: CollectionResource | null): any;
-    /**
-     * @deprecated
-     */
-    addItemsToCollections(itemEntries: ItemEntry[]): ItemResource[];
-    addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: ItemResource | null): ItemResource[];
-    batchExpand(parentType: string, itemType: string, collections: CollectionResource[], newColumns: any): Promise<CollectionResource[]>;
-    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): Promise<ItemResourceItemIdMap>;
-    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
-    clone(collectionEntry: CollectionEntry, options: any, conversionMap?: {}): CollectionEntry;
-    create(itemType: string, options: any, columns: any, items: ItemEntry[]): CollectionEntry;
-    createCollectionMap(itemEntries: ItemEntry[]): {};
-    createStatusResource(parentType: string, parentIdArray: number[], itemType: string, options: any, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
-    expandCollectionMap(itemEntry: ItemEntry, accumulator: any, collectionCache?: CollectionCache): void;
-    fetch(itemType: string, options: any, itemCache: ItemCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntry>;
-    getDeferredEntryStatus(collectionEntry: CollectionEntry, options: any): EntryStatus<CollectionEntry>;
-    getEntryStatus(itemType: string, options: any, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
-    getNewEntryStatus(itemType: string, query: any, options: any, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
-    handleBatchResponse(statusResource: any, itemEntryResource: any): CollectionEntryParentIdMap;
-    /**
-     * @deprecated
-     */
-    removeItemsFromAndAddItemsToCollections(itemEntries: ItemEntry[]): void;
-    /**
-     * @deprecated
-     */
-    removeItemsFromCollections(itemEntries: ItemEntry[]): any;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): Promise<CollectionEntry>;
-    resolveRemote(collectionEntry: any, itemCache: any): Promise<CollectionEntry>;
-}
+import { CollectionCache, CollectionEntryService, CollectionMatcher, ColumnHandler, ColumnUtil, ItemCache, ItemRequestService, KeyService, QueryService } from '../classes';
+import { CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource, ItemResource } from '../models';
+import { CollectionEntryBatchStatusMap, CollectionEntryParentIdMap, EntryStatus, ItemResourceItemIdMap } from '../types';
+export declare class CollectionHandler {
+    private errorHandler;
+    private itemRequestService;
+    private columnHandler;
+    private collectionEntryFactory;
+    private collectionCacheFactory;
+    private queryParserFactory;
+    private collectionEntryService;
+    private columnSetFactory;
+    private keyService;
+    private promiseService;
+    private queryService;
+    private columnUtil;
+    private collectionMatcherFactory;
+    entries: CollectionCache;
+    constructor(errorHandler: ErrorHandlerInterface, itemRequestService: ItemRequestService, columnHandler: ColumnHandler, collectionEntryFactory: CollectionEntryFactory, collectionCacheFactory: CollectionCacheFactory, queryParserFactory: QueryParserFactory, collectionEntryService: CollectionEntryService, columnSetFactory: ColumnSetFactory, keyService: KeyService, promiseService: PromiseInterface, queryService: QueryService, columnUtil: ColumnUtil, 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: string, itemType: string, collections: CollectionResource[], newColumns: any): Promise<CollectionResource[]>;
+    batchExtend(parentType: string, itemType: string, options: any, queryCallback: any, collections: CollectionResource[], returnAllItems?: boolean): Promise<ItemResourceItemIdMap>;
+    batchFetch(parentType: string, parentIdArray: number[], itemType: string, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
+    createStatusResource(parentType: string, parentIdArray: number[], itemType: string, options: any, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): CollectionEntryBatchStatusMap;
+    fetch(itemType: string, options: any, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntry>;
+    getDeferredEntryStatus(collectionEntry: CollectionEntry, options: any): EntryStatus<CollectionEntry>;
+    getEntryStatus(itemType: string, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
+    getNewEntryStatus(itemType: string, query: any, options: any, localEntries: CollectionCache, deferredEntries: CollectionCache): EntryStatus<CollectionEntry>;
+    handleBatchResponse(statusResource: any, itemEntryResource: any, itemCache: ItemCache): CollectionEntryParentIdMap;
+    resolveLocal(collectionEntry: CollectionEntry, itemCache: any): Promise<CollectionEntry>;
+    resolveRemote(collectionEntry: any, itemCache: any): Promise<CollectionEntry>;
+    isLocal(options: any): boolean;
+}

package/dist/dist/classes/CollectionMatcher.d.ts

@@ -0,0 +1,28 @@
+import { CollectionCache } from '../classes';
+import { QueryMatcherFactory } from '../factories/';
+import { CollectionEntry, CollectionResource, ItemEntry, ItemResource } from '../models';
+export declare class CollectionMatcher {
+    private queryMatcherFactory;
+    private collectionCaches;
+    private updateInitial;
+    map: {
+        [collectionEntryId: number]: {
+            collection: CollectionEntry;
+            matches: {
+                [itemId: number]: {
+                    item: ItemEntry;
+                    isMatch: boolean;
+                };
+            };
+        };
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean);
+    expand(itemEntry: ItemEntry): Window;
+    getCollectionsWithFittingItems(): CollectionEntry[];
+    addToCollections(resultResource?: CollectionResource | null): ItemResource[] | null;
+    removeFromCollections(resultResource?: CollectionResource | null): ItemResource[] | null;
+    removeFromAndAddToCollections(): void;
+    private groupItemEntries(matches);
+    private groupItemIds(matches);
+    private hasFittingItems(matches);
+}

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

@@ -1,5 +1,5 @@
-import { ItemResource } from "../models";
-export declare class CollectionResourceService {
-    processOptions(options: any): any;
-    getIdArray(itemResources: ItemResource[]): any[];
-}
+import { ItemResource } from '../models';
+export declare class CollectionResourceService {
+    processOptions(options: any): any;
+    getIdArray(itemResources: ItemResource[]): number[];
+}

package/dist/dist/classes/ColumnCache.d.ts

@@ -1,18 +1,18 @@
-import { ColumnUtil } from './ColumnUtil';
-export declare class ColumnCache {
-    private columnUtil;
-    cache: {};
-    allColumns: {};
-    constructor(columnUtil: ColumnUtil);
-    setColumn(itemType: any, responseColumn: any): any;
-    setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
-    retrieve(itemType: any, requestColumns: any): {
-        missing: any[] | true;
-        cached: object;
-    };
-    containsAll(itemType: any): boolean;
-    getColumns(itemType: any): {};
-    private retrieveColumns(itemType, requestColumns, requestAccumulator, responseAccumulator);
-    private retrieveColumn(itemType, requestColumn, requestAccumulator, responseAccumulator);
-    private getColumn(itemType, columnId);
-}
+import { ColumnUtil } from './ColumnUtil';
+export declare class ColumnCache {
+    private columnUtil;
+    cache: {};
+    allColumns: {};
+    constructor(columnUtil: ColumnUtil);
+    setColumn(itemType: any, responseColumn: any): any;
+    setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
+    retrieve(itemType: any, requestColumns: any): {
+        missing: any[] | true;
+        cached: object;
+    };
+    containsAll(itemType: any): boolean;
+    getColumns(itemType: any): {};
+    private retrieveColumns(itemType, requestColumns, requestAccumulator, responseAccumulator);
+    private retrieveColumn(itemType, requestColumn, requestAccumulator, responseAccumulator);
+    private getColumn(itemType, columnId);
+}

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

@@ -1,16 +1,14 @@
-import { ColumnSetFactory } from "../factories";
-import { ColumnHandler } from "./ColumnHandler";
-import { ColumnUtil } from "./ColumnUtil";
-export declare class ColumnExpansion {
-    private columnHandler;
-    private columnSetFactory;
-    private columnUtil;
-    itemType: string;
-    requestColumns: any | boolean;
-    responseColumns: any;
-    expansionMap: any;
-    requestColumnsTrue: boolean;
-    constructor(columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, itemType: string, requestColumns: any | boolean, responseColumns: any);
-    run(columnInfo: any, returnExpansionResult: boolean): any;
-    private expandColumnInfo(columnInfo);
-}
+import { ColumnUtil } from '../classes';
+import { ColumnSetFactory } from '../factories';
+export declare class ColumnExpansion {
+    private columnSetFactory;
+    private columnUtil;
+    itemType: string;
+    requestColumns: any | boolean;
+    responseColumns: any;
+    expansionMap: any;
+    requestColumnsTrue: boolean;
+    constructor(columnSetFactory: ColumnSetFactory, columnUtil: ColumnUtil, itemType: string, requestColumns: any | boolean, responseColumns: any);
+    run(columnInfo: any, returnExpansionResult: boolean): any;
+    private expandColumnInfo(columnSet);
+}

package/dist/dist/classes/ColumnHandler.d.ts

@@ -1,17 +1,16 @@
-import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
-import { ColumnCache } from './ColumnCache';
-import { ColumnUtil } from './ColumnUtil';
-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);
-    setColumn(itemType: any, responseColumn: any): any;
-    setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
-    fetchItemTypeTranslations(itemTypes: any): Promise<any>;
-    request(itemType: any, columns: any, params?: {}): Promise<any>;
-    fetch(itemType: any, requestColumns: any, params?: {}): Promise<any>;
-    fetchAll(itemType: any): Promise<any>;
-}
+import { ColumnCache, ColumnUtil } from '../classes';
+import { ApiRequestServiceInterface, ErrorHandlerInterface, PromiseInterface } from '../interfaces';
+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);
+    setColumn(itemType: any, responseColumn: any): any;
+    setColumns(itemType: any, requestColumns: any, responseColumns: any): {};
+    fetchItemTypeTranslations(itemTypes: any): Promise<any>;
+    request(itemType: any, columns: any, params?: {}): Promise<any>;
+    fetch(itemType: any, requestColumns: any, params?: {}): Promise<any>;
+    fetchAll(itemType: any): Promise<any>;
+}

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

@@ -0,0 +1,12 @@
+export declare class ColumnInfo {
+    readonly apiColumn: any;
+    readonly parent: ColumnInfo | null;
+    id: string;
+    level: number;
+    path: string;
+    tailPath: string;
+    itemType: string;
+    children: ColumnInfo[];
+    isLeaf: boolean;
+    constructor(apiColumn: any, parent?: ColumnInfo | null);
+}

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

@@ -1,54 +1,34 @@
-import { ColumnHandler } from './ColumnHandler';
-import { ColumnUtil } from './ColumnUtil';
-export declare class ColumnSet {
-    private columnHandler;
-    private columnUtil;
-    itemType: any;
-    requestColumns: any;
-    responseColumns: any;
-    enableCaching: boolean;
-    includeIdColumn: boolean;
-    id: number;
-    true: boolean;
-    link: any;
-    main: any[];
-    derived: any[];
-    root: any[];
-    leaf: any[];
-    formatted: {
-        main: any[];
-        derived: any[];
-    };
-    filtered: any[];
-    custom: any[];
-    searchable: any[];
-    item: any[];
-    notItem: any[];
-    request: any[];
-    response: {};
-    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, itemType: any, requestColumns: any, responseColumns: any, enableCaching?: boolean, includeIdColumn?: boolean);
-    processResponseColumns(): void;
-    processRequestColumns(): void;
-    getRequestColumnInfo(requestColumn: any, columnType: any, parent: any): {
-        id: any;
-        path: any;
-        apiColumn: any;
-        level: any;
-        isLeaf: boolean;
-        itemType: string;
-        children: any[];
-        parent: any;
-        tailPath: any;
-    };
-    getColumnInfo(responseColumn: any, children: any, parent: any): {
-        id: any;
-        path: any;
-        apiColumn: any;
-        level: any;
-        isLeaf: boolean;
-        itemType: string;
-        children: any[];
-        parent: any;
-        tailPath: any;
-    };
-}
+import { ColumnHandler, ColumnInfo, ColumnUtil } from '../classes';
+import { ColumnInfoFactory } from '../factories';
+import { RequestColumns, ResponseColumnMap } from '../types';
+export declare class ColumnSet {
+    private columnHandler;
+    private columnUtil;
+    private columnInfoFactory;
+    itemType: any;
+    request: RequestColumns;
+    id: number;
+    requestColumnsTrue: boolean;
+    response: ResponseColumnMap;
+    link: ColumnInfo | null;
+    main: ColumnInfo[];
+    derived: ColumnInfo[];
+    root: ColumnInfo[];
+    leaf: ColumnInfo[];
+    formatted: {
+        main: ColumnInfo[];
+        derived: ColumnInfo[];
+    };
+    filtered: ColumnInfo[];
+    custom: ColumnInfo[];
+    searchable: ColumnInfo[];
+    item: ColumnInfo[];
+    notItem: ColumnInfo[];
+    enableCaching: boolean;
+    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, itemType: any, request: RequestColumns);
+    resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
+    private processResponseColumns(responseColumns);
+    private processRequestColumns(responseColumns, includeIdColumn);
+    private getRequestColumnInfo(requestColumn, columnType, parent, responseColumns);
+    private getColumnInfo(columnId, columnType, children, parent, responseColumns);
+}

package/dist/dist/classes/ColumnUtil.d.ts

@@ -1,81 +1,79 @@
-export declare class ColumnUtil {
-    constructor();
-    getColumnPath(columns: any, renderAs: any): string;
-    getDateFormatOptions(columnType: any): {
-        'J-M-Y': string;
-        'J-M': string;
-        'j+F+Y': string;
-        'D+j+F+Y': string;
-        'F': string;
-        'f': string;
-        'D': string;
-        'd': string;
-    };
-    isStringColumn(column: any): boolean;
-    isFloatColumn(column: any): boolean;
-    isIntColumn(column: any): boolean;
-    isNumberColumn(column: any): boolean;
-    isCustomColumn(column: any): boolean;
-    isItemColumn(column: any, includeId?: boolean): boolean;
-    isDateColumn(column: any): boolean;
-    isRenderedColumn(column: any): boolean;
-    isFilteredColumn(column: any): boolean;
-    isFormattedColumn(column: any): boolean;
-    isSelectableColumn(column: any): boolean;
-    hasLocationProperty(column: any, location: any): boolean;
-    isEditableColumn(column: any): boolean;
-    isSearchableColumn(column: any): boolean;
-    getDefaultWeight(column: any): 1 | 2 | 0.5 | 1.5;
-    getComparators(column: any): string[];
-    isColumnSubset(first: any, second: any, secondTrue: any): any;
-    containsColumn(requestColumn: any, destination: any): boolean;
-    responseColumnsAvailable(itemType: any, requestColumns: any, responseColumnMap: any): boolean;
-    /**
-     * Difference: columns that are in second, but not in first
-     * @param {Array} first
-     * @param {Array} second
-     * @returns {Object} An object containing 'merged' and 'difference' properties
-     */
-    mergeRequestColumns(first: any, second: any): {
-        merged: boolean;
-        difference: boolean;
-    } | {
-        merged: any;
-        difference: any[];
-    };
-    mergeRequestColumn(requestColumn: any, destination: any): any;
-    parseRequestColumn(requestColumn: any): {
-        id: any;
-        children: any;
-    };
-    /**
-     * Merges two sets of response columns.
-     * @param {object} first
-     * @param {object} second
-     * @returns {object} An object containing a 'merged' and a 'difference' property.
-     */
-    mergeResponseColumns(first: any, second: any): {
-        merged: {};
-        difference: {};
-    };
-    /**
-     * @param {array} first
-     * @param {array} second
-     * @returns {object} difference: the columns that are in second, but not in first.
-     */
-    mergeResponseColumnMap(first: any, second: any): {
-        merged: {};
-        difference: {};
-    };
-    isLocalColumnId(columnId: any): boolean;
-    processConfigColumns(columns: any): any[];
-    processLocalConfigColumns(configColumns: any, localColumns: any, remoteColumnCallback: any, localColumnCallback: any): void;
-    consolidateColumns(configColumns: any, localColumns: any, addRequestColumns: any): {
-        request: any;
-        local: any[];
-    };
-    parseConfigColumn(column: any): any;
-    processConfigColumn(columnArray: any, destination: any): void;
-    findColumnObject(columnId: any, array: any): number;
-    findColumn(columnId: any, array: any): number;
-}
+import { RequestColumns } from '../types';
+export declare class ColumnUtil {
+    constructor();
+    getColumnPath(columns: any, renderAs: any): string;
+    getDateFormatOptions(columnType: any): {
+        'J-M-Y': string;
+        'J-M': string;
+        'j+F+Y': string;
+        'D+j+F+Y': string;
+        'F': string;
+        'f': string;
+        'D': string;
+        'd': string;
+    };
+    isStringColumn(column: any): boolean;
+    isFloatColumn(column: any): boolean;
+    isIntColumn(column: any): boolean;
+    isNumberColumn(column: any): boolean;
+    isCustomColumn(column: any): boolean;
+    isItemColumn(column: any, includeId?: boolean): boolean;
+    isDateColumn(column: any): boolean;
+    isRenderedColumn(column: any): boolean;
+    isFilteredColumn(column: any): boolean;
+    isFormattedColumn(column: any): boolean;
+    isSelectableColumn(column: any): boolean;
+    hasLocationProperty(column: any, location: any): boolean;
+    isEditableColumn(column: any): boolean;
+    isSearchableColumn(column: any): boolean;
+    getDefaultWeight(column: any): 1 | 2 | 0.5 | 1.5;
+    getComparators(column: any): string[];
+    isColumnSubset(first: any, second: any, secondTrue: any): any;
+    containsColumn(requestColumn: any, destination: any): boolean;
+    responseColumnsAvailable(itemType: any, requestColumns: any, responseColumnMap: any): boolean;
+    /**
+     * Difference: columns that are in second, but not in first
+     * @param {Array} first
+     * @param {Array} second
+     * @returns {Object} An object containing 'merged' and 'difference' properties
+     */
+    mergeRequestColumns(first: any, second: any): {
+        merged: RequestColumns;
+        difference: RequestColumns;
+    };
+    mergeRequestColumn(requestColumn: any, destination: any): any;
+    parseRequestColumn(requestColumn: any): {
+        id: any;
+        children: any;
+    };
+    /**
+     * Merges two sets of response columns.
+     * @param {object} first
+     * @param {object} second
+     * @returns {object} An object containing a 'merged' and a 'difference' property.
+     */
+    mergeResponseColumns(first: any, second: any): {
+        merged: {};
+        difference: {};
+    };
+    /**
+     * @param {array} first
+     * @param {array} second
+     * @returns {object} difference: the columns that are in second, but not in first.
+     */
+    mergeResponseColumnMap(first: any, second: any): {
+        merged: {};
+        difference: {};
+    };
+    isLocalColumnId(columnId: any): boolean;
+    processConfigColumns(columns: any): never[];
+    processLocalConfigColumns(configColumns: any, localColumns: any, remoteColumnCallback: any, localColumnCallback: any): void;
+    consolidateColumns(configColumns: any, localColumns: any, addRequestColumns: any): {
+        request: any;
+        local: object[];
+    };
+    parseConfigColumn(column: any): any;
+    processConfigColumn(columnArray: any, destination: any): void;
+    findColumnObject(columnId: any, array: any): number;
+    findColumn(columnId: any, array: any): number;
+}

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

@@ -1,20 +1,20 @@
-import { RequestColumnExpansionFactory } from "../factories";
-import { CollectionHandler } from "./CollectionHandler";
-import { ItemEntryService } from "./ItemEntryService";
-import { KeyService } from "./KeyService";
-export declare class CreateRequest {
-    private collectionHandler;
-    private requestColumnExpansionFactory;
-    private itemEntryService;
-    private keyService;
-    private compilation;
-    private parameterMap;
-    private breakupByParent;
-    requests: any[];
-    constructor(collectionHandler: CollectionHandler, requestColumnExpansionFactory: RequestColumnExpansionFactory, itemEntryService: ItemEntryService, keyService: KeyService, compilation: any, parameterMap: any, breakupByParent?: boolean);
-    finalizeRequest(requestResource: any): any;
-    setRequestParent(parentType: any, requestResource: any): boolean;
-    run(): any[];
-    initializeRequest(): any;
-    private extendRequest(itemEntries, requestParentId, destination);
-}
+import { CollectionCache, CollectionHandler, KeyService } from '../classes';
+import { CollectionMatcherFactory, RequestColumnExpansionFactory } from '../factories';
+import { CreateRequestEntry } from '../types';
+export declare class CreateRequest {
+    private collectionHandler;
+    private collectionMatcherFactory;
+    private keyService;
+    private requestColumnExpansionFactory;
+    private compilation;
+    private localCollectionCache;
+    private parameterMap;
+    private breakupByParent;
+    requests: CreateRequestEntry[];
+    constructor(collectionHandler: CollectionHandler, collectionMatcherFactory: CollectionMatcherFactory, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: any, localCollectionCache: CollectionCache, parameterMap: any, breakupByParent?: boolean);
+    finalizeRequest(requestResource: CreateRequestEntry): CreateRequestEntry;
+    setRequestParent(parentType: any, requestResource: any): boolean;
+    run(): CreateRequestEntry[];
+    initializeRequest(): CreateRequestEntry;
+    private extendRequest(itemEntries, requestParentId, destination);
+}