@rentman/rm-core 1.5.5 → 1.5.7-1

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

@@ -1,4 +1,3 @@
-/// <reference types="moment" />
 import * as moment from 'moment';
 import { ColumnInfo } from '../classes';
 import { FieldMap } from '../types';
@@ -17,24 +16,24 @@ export declare class ApiFormatter {
     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 | "0" | moment.Moment | moment.Duration | "" | "#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;
+    compareFields(columnType: string, first?: any, second?: any): boolean;
+    compareFloats(a: number, b: number): boolean;
+    compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
+    compareDurations(first: moment.Duration, second: moment.Duration): boolean;
+    formatResponseValue(columnType: string, value: any): any;
+    formatRequestValue(columnType: string, value: any): any;
+    formatResponseDate(value: null | any): moment.Moment;
+    formatResponseDuration(value: null | number): moment.Duration;
+    formatResponseColor(value: string): string;
+    formatRequestDateTime(value: moment.Moment): string | null;
+    formatRequestDate(value: moment.Moment): string | null;
+    formatRequestDuration(value: moment.Duration): number;
+    formatRequestColor(value: string): string;
+    getDefaultValue(columnType: string): any;
+    isDefaultValue(columnType: string, value: any): boolean;
+    clone(columnType: string, value: any): any;
+    getCloneFunction(columnType: string): ((duration: moment.Duration) => moment.Duration) | ((date: moment.Moment) => moment.Moment);
+    cloneDuration(duration: moment.Duration): moment.Duration;
+    cloneDate(date: moment.Moment): moment.Moment;
+    identity<T>(input: T): T;
 }

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

@@ -1,10 +1,14 @@
 import { ApiFormatter } from '../classes';
-import { ItemTypeMap } from '../types';
+import { FieldMap, ItemId, ItemType, ItemTypeMap, ResponseColumn } from '../types';
 export declare class ApiResponseProcessor {
     apiFormatter: ApiFormatter;
     response: any;
     columns: ItemTypeMap;
-    items: ItemTypeMap;
+    items: {
+        [itemType: string]: {
+            [itemId: number]: any;
+        };
+    };
     links: ItemTypeMap;
     cacheable: boolean;
     map: any;
@@ -12,22 +16,26 @@ export declare class ApiResponseProcessor {
     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): {
+    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[]): any[];
+    fetchObjectMap(itemType: ItemType, columnId: string, includeLinks?: boolean, returnKeys?: boolean): {
         [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;
+    fetchFieldMap(itemType: ItemType, columnId: string): {
+        [itemId: number]: FieldMap;
+    };
+    fetchColumnArray(itemType: ItemType): ResponseColumn[];
+    fetchColumnObject(itemType: ItemType): ResponseColumn;
+    fetchColumnsObject(): {
+        [itemType: string]: ResponseColumn;
+    };
+    createResource(itemType: ItemType, id: ItemId): {
+        object: FieldMap;
         links: any;
     };
-    hasItems(itemType: any): boolean;
-    getIdArray(itemType: any): string[];
+    hasItems(itemType: ItemType): boolean;
+    getIdArray(itemType: ItemType): ItemId[];
 }

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

@@ -44,8 +44,8 @@ export declare class ChangesCompilation {
     addUpdateEntry(itemEntry: ItemEntry): void;
     addCreateEntry(itemEntry: ItemEntry): void;
     containsCreateEntry(itemType: ItemType, itemId: ItemId): boolean;
-    private createDeleteCompilation();
+    private createDeleteCompilation;
     postProcess(): void;
-    private processSingleItems();
-    private processCollections(collectionEntries);
+    private processSingleItems;
+    private processCollections;
 }

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

@@ -1,8 +1,8 @@
-import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler } from '../classes';
+import { ApiFormatter, CollectionEntryService, CollectionHandler, ItemHandler, MoveMapEntry } 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';
+import { ApiRequestMoveItems, CreateRequestParameterMap, ItemId, ItemIdConversionMap, ItemType, PromiseInterface } from '../types';
 export declare class ChangesProcessor {
     private apiFormatter;
     private apiRequestService;
@@ -16,18 +16,18 @@ 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: 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);
+    buildMoveRequest(compilationEntries: MoveMapEntry[]): ApiRequestMoveItems;
+    getMapValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+    private executeMoveRequests;
+    private processMoveResponse;
+    private addCollectionMapEntry;
+    private forEachCollection;
+    private onItemsCreated;
     execute(singleItems: ItemEntry[], collections: CollectionEntry[], parameters?: CreateRequestParameterMap, breakupByParent?: boolean, onAfterCreateCallback?: (conversionMap: ItemIdConversionMap) => void): PromiseInterface<ItemIdConversionMap>;
 }

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

@@ -1,6 +1,6 @@
 import { QueryMatcherFactory } from '../factories';
 import { CollectionEntry, CollectionResource } from '../models';
-import { CollectionMatchResult, EntryParentNull, FieldMap, ItemType } from '../types';
+import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
 export declare class CollectionCache {
     private queryMatcherFactory;
     entries: {
@@ -16,22 +16,22 @@ export declare class CollectionCache {
     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[];
+    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[];
     /**
      * Only resources
      * @param {String} itemType
      * @param {String|Integer} itemId
      * @returns {Object} Array of collections.
      */
-    getByContainingItem(itemType: any, itemId: any): CollectionEntry[];
+    getByContainingItem(itemType: ItemType, itemId: ItemId): 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[];
+    getByQuery(itemType: ItemType, query: CollectionQuery): CollectionEntry | null;
+    getByKey(itemType: ItemType, entryKey: string): CollectionEntry[];
+    getResourceByKey(itemType: ItemType, resourceKey: string): CollectionResource[];
 }

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

@@ -1,19 +1,16 @@
 import { QueryService } from '../classes';
 import { QueryParserFactory } from '../factories';
 import { CollectionEntryOptions, ItemEntry } from '../models';
-import { CollectionOptionsInterface, EntryParentNull, ItemId } from '../types';
+import { CollectionOptionsInterface, CollectionQuery, EntryParentNull, ItemId } 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;
-    cloneQueryParams(parameters: any): {};
-    createQuery(options: any): {
-        object: any;
-        string: any;
-    };
-    getIdArray(itemEntries: ItemEntry[], accumulator: any): ItemId[];
+    cloneQueryParams<T extends object>(parameters: T): T;
+    createQuery(options: CollectionEntryOptions): CollectionQuery;
+    getIdArray(itemEntries: ItemEntry[], accumulator?: ItemId[]): ItemId[];
     /**
      * @param {ItemEntry[]} itemEntries
      * @param {(itemEntry: ItemEntry) => boolean} callback

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

@@ -1,9 +1,9 @@
-import { CollectionEntryOptions, PromiseInterface } from '../';
+import { CollectionEntryOptions, CollectionViewResource, PromiseInterface } from '../';
 import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
 import { ENTRY_STATUS } from '../constants';
 import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource, ItemResource } from '../models';
+import { CollectionEntry, CollectionResource } from '../models';
 import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, EntryStatus, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, QueryCallback } from '../types';
 export declare class CollectionHandler {
     private batchStatusFactory;
@@ -25,19 +25,19 @@ export declare class CollectionHandler {
     /**
      * @deprecated, use collectionMatcherFactory
      */
-    removeFromAndAddToCollections(collectionMap: any, updateInitial?: any): void;
+    removeFromAndAddToCollections(collectionMap: any, updateInitial?: boolean): void;
     getCollectionMatcher(): CollectionMatcher;
     /**
      * @deprecated, use collectionMatcherFactory
      */
-    removeFromCollections(collectionMap: any, updateInitial?: any, resultResource?: CollectionResource | null): any;
+    removeFromCollections<T extends CollectionResource = CollectionViewResource>(collectionMap: any, updateInitial?: boolean, resultResource?: T | null): T['items'] | null;
     /**
      * @deprecated, use collectionMatcherFactory
      */
-    addToCollections(collectionMap: any, updateInitial: boolean, resultResource?: CollectionResource | null): ItemResource[];
+    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>;
-    batchExtend(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: CollectionResourceParentIdMap, returnAllItems?: boolean): PromiseInterface<ItemResourceItemIdMap>;
-    batchFetch(parentType: ItemType, parentIdArray: ItemId[], itemType: ItemType, options: CollectionEntryOptions, itemCache: ItemCache, localCollectionCache: CollectionCache, deferredCollectionCache: CollectionCache): Promise<CollectionEntryParentIdMap>;
+    batchExtend<T extends CollectionResourceParentIdMap>(parentType: ItemType, itemType: ItemType, options: CollectionEntryOptions, queryCallback: QueryCallback, collections: T, returnAllItems?: 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;
@@ -53,5 +53,5 @@ export declare class CollectionHandler {
     resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
     isLocal(options: any): boolean;
-    private expandLocalItemEntries(itemType, itemEntries, columnSet, localItemCache);
+    private expandLocalItemEntries;
 }

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

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

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

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

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

@@ -7,7 +7,7 @@ export declare class ColumnCache {
         [itemType: string]: boolean;
     };
     constructor(columnUtil: ColumnUtil);
-    setColumn(itemType: ItemType, responseColumn: ResponseColumn): any;
+    setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
     setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
     retrieve(itemType: ItemType, requestColumns: ApiRequestColumns): {
         cached: ResponseColumnMap;
@@ -15,7 +15,7 @@ export declare class ColumnCache {
     };
     containsAll(itemType: ItemType): boolean;
     getColumns(itemType: ItemType): ResponseColumnMap;
-    private retrieveColumns(itemType, requestColumns, requestAccumulator, responseAccumulator);
-    private retrieveColumn(itemType, requestColumn, requestAccumulator, responseAccumulator);
-    private getColumn(itemType, columnId);
+    private retrieveColumns;
+    private retrieveColumn;
+    private getColumn;
 }

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

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

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

@@ -34,13 +34,13 @@ export declare class ColumnSet {
     resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
     expandRequestColumns(columns: ApiRequestColumns): void;
     isSupersetOf(columns: ApiRequestColumns): boolean;
-    private processResponseColumns(responseColumns);
-    private requestColumnsIsTrue(requestColumns);
-    private processRequestColumns(responseColumns, includeIdColumn);
-    private getRequestColumnInfo(requestColumn, itemType, parent, responseColumns);
-    private getColumnInfo(columnId, itemType, children, parent, responseColumns);
-    private getColumnSetExpansion(requestColumns, responseColumns);
-    private getMergedColumnSet(columnSetExpansion, requestColumnsTrue);
+    private processResponseColumns;
+    private requestColumnsIsTrue;
+    private processRequestColumns;
+    private getRequestColumnInfo;
+    private getColumnInfo;
+    private getColumnSetExpansion;
+    private getMergedColumnSet;
     merge(columnSet: ColumnSet): ColumnSet;
     expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
 }

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

@@ -1,8 +1,8 @@
-import { ApiRequestColumn, ApiRequestColumns, ItemType, ResponseColumnMap } from '../types';
+import { ApiRequestColumn, ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnMap } from '../types';
 export declare class ColumnUtil {
     constructor();
-    getColumnPath(columns: any, renderAs: any): string;
-    getDateFormatOptions(columnType: any): {
+    getColumnPath(columns: ResponseColumn[], renderAs: null | string): string;
+    getDateFormatOptions(columnType?: 'datetime'): {
         'J-M-Y': string;
         'J-M': string;
         'j+F+Y': string;
@@ -12,22 +12,28 @@ export declare class ColumnUtil {
         '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 | 0.5 | 1.5 | 2;
-    getComparators(column: any): string[];
+    isStringColumn(column: ResponseColumn): boolean;
+    isFloatColumn(column: ResponseColumn): boolean;
+    isIntColumn(column: ResponseColumn): boolean;
+    isNumberColumn(column: ResponseColumn): boolean;
+    isCustomColumn(column: ResponseColumn): boolean;
+    isItemColumn(column: ResponseColumn, includeId?: boolean): boolean;
+    isDateColumn(column: ResponseColumn): boolean;
+    isRenderedColumn(column: ResponseColumn): boolean;
+    isFilteredColumn(column: ResponseColumn): boolean;
+    isFormattedColumn(column: ResponseColumn): boolean;
+    isSelectableColumn(column: ResponseColumn): boolean;
+    hasLocationProperty(column: ResponseColumn, location: number): boolean;
+    isEditableColumn(column: ResponseColumn): boolean;
+    isSearchableColumn(column: ResponseColumn): boolean;
+    getDefaultWeight(column: ResponseColumn): number;
+    getComparators(column: ResponseColumn & {
+        type: 'dimension' | 'weight' | 'price';
+    }): ['=', '>', '<'];
+    getComparators(column: ResponseColumn & {
+        type: 'date' | 'datetime' | 'time' | 'duration';
+    }): ['>', '<'];
+    getComparators(column: ResponseColumn): ['=', '!='];
     containsColumn(requestColumn: ApiRequestColumn, destination: ApiRequestColumn[]): boolean;
     containsDerivedColumns(requestColumns: ApiRequestColumn[]): boolean;
     responseColumnsAvailable(itemType: ItemType, requestColumns: ApiRequestColumn[], responseColumnMap: ResponseColumnMap): boolean;
@@ -40,6 +46,14 @@ export declare class ColumnUtil {
      * @param {Array} second
      * @returns {Object} An object containing 'merged' and 'difference' properties
      */
+    mergeRequestColumns(first: true, second: ApiRequestColumns): {
+        merged: true;
+        difference: [];
+    };
+    mergeRequestColumns(first: ApiRequestColumn[], second: true): {
+        merged: true;
+        difference: true;
+    };
     mergeRequestColumns(first: ApiRequestColumn[], second: ApiRequestColumn[]): {
         merged: ApiRequestColumn[];
         difference: ApiRequestColumn[];
@@ -71,9 +85,9 @@ export declare class ColumnUtil {
      * @param {array} second
      * @returns {object} difference: the columns that are in second, but not in first.
      */
-    mergeResponseColumnMap(first: any, second: any): {
-        merged: {};
-        difference: {};
+    mergeResponseColumnMap(first: ResponseColumnMap, second: ResponseColumnMap): {
+        merged: ResponseColumnMap;
+        difference: ResponseColumnMap;
     };
     isLocalColumnId(columnId: string): boolean;
     processConfigColumns(configColumns: string[]): ApiRequestColumn[];

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

@@ -16,5 +16,5 @@ export declare class CreateRequest {
     setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry): boolean;
     run(): CreateRequestEntry[];
     initializeRequest(): CreateRequestEntry;
-    private extendRequest(itemEntries, requestParentId, destination);
+    private extendRequest;
 }