@rentman/rm-core 1.7.1 → 1.7.3

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

@@ -1,54 +1,54 @@
-import { CollectionEntryOptions, CollectionViewResource, PromiseInterface } from '../';
-import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
-import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { CollectionEntry, CollectionResource } from '../models';
-import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, QueryCallback } from '../types';
-export declare class CollectionHandler {
-    private batchStatusFactory;
-    private collectionCacheFactory;
-    private collectionEntryFactory;
-    private collectionEntryService;
-    private collectionMatcherFactory;
-    private columnHandler;
-    private columnSetFactory;
-    private errorHandler;
-    private itemHandler;
-    private itemRequestService;
-    private keyService;
-    private promiseService;
-    private queryParserFactory;
-    private queryService;
-    entries: CollectionCache;
-    constructor(batchStatusFactory: BatchStatusFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryParserFactory: QueryParserFactory, queryService: QueryService);
-    /**
-     * @deprecated, use collectionMatcherFactory
-     */
-    removeFromAndAddToCollections(collectionMap: any): void;
-    getCollectionMatcher(): CollectionMatcher;
-    /**
-     * @deprecated, use collectionMatcherFactory
-     */
-    removeFromCollections<T extends CollectionResource = CollectionViewResource>(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>;
-    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>;
-    private resolveCached;
-    private getCachedEntryStatus;
-    private getDeferredEntryStatus;
-    private getEntryStatus;
-    resolveLocal(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
-    resolveRemote(collectionEntry: CollectionEntry, itemCache: ItemCache): PromiseInterface<CollectionEntry>;
-    isLocal(options: any): boolean;
-    private expandLocalItemEntries;
-}
+import { CollectionEntryOptions, CollectionViewResource, PromiseInterface } from '../';
+import { BatchStatus, CollectionCache, CollectionEntryService, CollectionMatcher, ColumnExpansion, ColumnHandler, ColumnSet, ItemCache, ItemHandler, ItemRequestService, KeyService, QueryService } from '../classes';
+import { BatchStatusFactory, CollectionCacheFactory, CollectionEntryFactory, CollectionMatcherFactory, ColumnSetFactory, QueryParserFactory } from '../factories';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { CollectionEntry, CollectionResource } from '../models';
+import { ApiRequestColumn, CollectionEntryParentIdMap, CollectionResourceParentIdMap, ItemEntryParentIdMap, ItemId, ItemResourceItemIdMap, ItemType, QueryCallback } from '../types';
+export declare class CollectionHandler {
+    private batchStatusFactory;
+    private collectionCacheFactory;
+    private collectionEntryFactory;
+    private collectionEntryService;
+    private collectionMatcherFactory;
+    private columnHandler;
+    private columnSetFactory;
+    private errorHandler;
+    private itemHandler;
+    private itemRequestService;
+    private keyService;
+    private promiseService;
+    private queryParserFactory;
+    private queryService;
+    entries: CollectionCache;
+    constructor(batchStatusFactory: BatchStatusFactory, collectionCacheFactory: CollectionCacheFactory, collectionEntryFactory: CollectionEntryFactory, collectionEntryService: CollectionEntryService, collectionMatcherFactory: CollectionMatcherFactory, columnHandler: ColumnHandler, columnSetFactory: ColumnSetFactory, errorHandler: ErrorHandlerInterface, itemHandler: ItemHandler, itemRequestService: ItemRequestService, keyService: KeyService, promiseService: PromiseLibraryInterface, queryParserFactory: QueryParserFactory, queryService: QueryService);
+    /**
+     * @deprecated, use collectionMatcherFactory
+     */
+    removeFromAndAddToCollections(collectionMap: any): void;
+    getCollectionMatcher<ItemTypeType extends ItemType>(): CollectionMatcher<ItemTypeType>;
+    /**
+     * @deprecated, use collectionMatcherFactory
+     */
+    removeFromCollections<T extends CollectionResource<any> = CollectionViewResource<any>>(collectionMap: any, updateInitial?: boolean, resultResource?: T | null): T['items'] | null;
+    /**
+     * @deprecated, use collectionMatcherFactory
+     */
+    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<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<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,42 +1,42 @@
-import { ItemId } from '../';
-import { CollectionCache } from '../classes';
-import { QueryMatcherFactory } from '../factories/';
-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;
-    private updateInitial;
-    private callOnAdd;
-    private callOnActivate;
-    map: {
-        [collectionEntryId: number]: {
-            collection: CollectionEntry;
-            matches: CollectionMatcherMatches;
-        };
-    };
-    constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean);
-    expand(itemEntry: ItemEntry): this;
-    private _expand;
-    getCollectionsWithFittingItems(): CollectionEntry[];
-    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;
-    private groupItemIds;
-    private hasFittingItems;
-}
+import { ItemId, ItemType } from '../';
+import { CollectionCache } from '../classes';
+import { QueryMatcherFactory } from '../factories/';
+import { CollectionEntry, CollectionResource, ItemEntry } from '../models';
+export declare type CollectionMatcherMatches<ItemTypeType extends ItemType> = {
+    [itemId: number]: {
+        item: ItemEntry<ItemTypeType>;
+        isMatch: boolean | 'maybe';
+    };
+};
+export declare type GroupedCollectionMatcherResult<ItemTypeType extends ItemType> = {
+    fitting: Array<ItemEntry<ItemTypeType>>;
+    notFitting: ItemId[];
+    maybe: Array<ItemEntry<ItemTypeType>>;
+};
+export declare class CollectionMatcher<ItemTypeType extends ItemType> {
+    private queryMatcherFactory;
+    private collectionCaches;
+    private updateInitial;
+    private callOnAdd;
+    private callOnActivate;
+    map: {
+        [collectionEntryId: number]: {
+            collection: CollectionEntry<ItemTypeType>;
+            matches: CollectionMatcherMatches<ItemTypeType>;
+        };
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory, collectionCaches: CollectionCache[], updateInitial: boolean, callOnAdd: boolean, callOnActivate: boolean);
+    expand(itemEntry: ItemEntry<ItemTypeType>): this;
+    private _expand;
+    getCollectionsWithFittingItems(): Array<CollectionEntry<ItemTypeType>>;
+    addToCollections<U extends CollectionResource<ItemTypeType>>(resultResource: U): U['items'];
+    addToCollections(resultResource?: null): null;
+    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<ItemTypeType>>(resultResource?: CollectionResource<ItemTypeType> | null): U['items'] | null;
+    removeFromAndAddToCollections(): void;
+    private groupItemEntries;
+    private groupItemIds;
+    private hasFittingItems;
+}

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

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

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

@@ -1,21 +1,21 @@
-import { ColumnUtil } from '../classes';
-import { ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnMap } from '../types';
-export declare class ColumnCache {
-    private columnUtil;
-    cache: ResponseColumnMap;
-    allColumns: {
-        [itemType: string]: boolean;
-    };
-    constructor(columnUtil: ColumnUtil);
-    setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
-    setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
-    retrieve(itemType: ItemType, requestColumns: ApiRequestColumns): {
-        cached: ResponseColumnMap;
-        missing: ApiRequestColumns;
-    };
-    containsAll(itemType: ItemType): boolean;
-    getColumns(itemType: ItemType): ResponseColumnMap;
-    private retrieveColumns;
-    private retrieveColumn;
-    private getColumn;
-}
+import { ColumnUtil } from '../classes';
+import { ApiRequestColumns, ItemType, ResponseColumn, ResponseColumnMap } from '../types';
+export declare class ColumnCache {
+    private columnUtil;
+    cache: ResponseColumnMap;
+    allColumns: {
+        [itemType: string]: boolean;
+    };
+    constructor(columnUtil: ColumnUtil);
+    setColumn(itemType: ItemType, responseColumn: ResponseColumn): ResponseColumn;
+    setColumns(itemType: ItemType, requestColumns: ApiRequestColumns, responseColumns: ResponseColumnMap): ResponseColumnMap;
+    retrieve(itemType: ItemType, requestColumns: ApiRequestColumns): {
+        cached: ResponseColumnMap;
+        missing: ApiRequestColumns;
+    };
+    containsAll(itemType: ItemType): boolean;
+    getColumns(itemType: ItemType): ResponseColumnMap;
+    private retrieveColumns;
+    private retrieveColumn;
+    private getColumn;
+}

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

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

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

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

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

@@ -1,46 +1,46 @@
-import { ColumnHandler, ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
-import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
-import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
-export declare class ColumnSet {
-    private columnHandler;
-    private columnUtil;
-    private columnInfoFactory;
-    private columnSetFactory;
-    itemType: ItemType;
-    request: ApiRequestColumns;
-    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[];
-    constructor(columnHandler: ColumnHandler, columnUtil: ColumnUtil, columnInfoFactory: ColumnInfoFactory, columnSetFactory: ColumnSetFactory, itemType: ItemType, request: ApiRequestColumns);
-    toJSON(): {
-        main: string[];
-        derived: string[];
-    };
-    resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
-    expandRequestColumns(columns: ApiRequestColumns): void;
-    isSupersetOf(columns: ApiRequestColumns): boolean;
-    private processResponseColumns;
-    private processRequestColumns;
-    private processColumnInfo;
-    private createRootColumnMap;
-    private groupColumnInfo;
-    private getMergedColumnSet;
-    mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
-    mergeResponseColumns(responseColumns: ResponseColumnMap): ResponseColumnMap;
-    merge(columnSet: ColumnSet): ColumnSet;
-    expand(requestColumns: ApiRequestColumns, requestColumnsTrue: boolean, responseColumns: ResponseColumnMap): ColumnExpansionResult;
-}
+import { ColumnHandler, ColumnInfo, ColumnUtil, RequestColumnMergeResult } from '../classes';
+import { ColumnInfoFactory, ColumnSetFactory } from '../factories';
+import { ApiRequestColumns, ColumnExpansionResult, ItemType, ResponseColumnMap } from '../types';
+export declare class ColumnSet<ItemTypeType extends ItemType = any> {
+    private columnHandler;
+    private columnUtil;
+    private columnInfoFactory;
+    private columnSetFactory;
+    itemType: ItemTypeType;
+    request: ApiRequestColumns;
+    id: number;
+    requestColumnsTrue: boolean;
+    response: ResponseColumnMap;
+    link: ColumnInfo<ItemTypeType> | null;
+    main: Array<ColumnInfo<ItemTypeType>>;
+    derived: Array<ColumnInfo<ItemTypeType>>;
+    root: Array<ColumnInfo<ItemTypeType>>;
+    leaf: Array<ColumnInfo<ItemTypeType>>;
+    formatted: {
+        main: Array<ColumnInfo<ItemTypeType>>;
+        derived: Array<ColumnInfo<ItemTypeType>>;
+    };
+    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[];
+    };
+    resolve(responseColumns: ResponseColumnMap, enableCaching?: boolean, includeIdColumn?: boolean): this;
+    expandRequestColumns(columns: ApiRequestColumns): void;
+    isSupersetOf(columns: ApiRequestColumns): boolean;
+    private processResponseColumns;
+    private processRequestColumns;
+    private processColumnInfo;
+    private createRootColumnMap;
+    private groupColumnInfo;
+    private getMergedColumnSet;
+    mergeRequestColumns(requestColumns: ApiRequestColumns): RequestColumnMergeResult;
+    mergeResponseColumns(responseColumns: ResponseColumnMap): ResponseColumnMap;
+    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 {
-    requestColumns: ApiRequestColumns;
-    private cache;
-    constructor(requestColumns: ApiRequestColumns);
-    run(columnSet: ColumnSet): boolean;
-}
+import { ColumnSet } from '../classes';
+import { ApiRequestColumns, ItemType } from '../types';
+export declare class ColumnSubsetCache<ItemTypeType extends ItemType> {
+    requestColumns: ApiRequestColumns;
+    private cache;
+    constructor(requestColumns: ApiRequestColumns);
+    run(columnSet: ColumnSet<ItemTypeType>): boolean;
+}