@rentman/rm-core 12.1.2 → 12.1.4

package/dist/types/src/classes/QueryLocallyMatchableParser.d.ts

@@ -1,20 +1,20 @@
-import { ApiQueryConditionLinkedTo } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryWithConditions, QueryParserBase } from '../internal';
-declare type ReturnType = boolean;
-/**
- * @description
- * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
- */
-export declare class QueryLocallyMatchableParser extends QueryParserBase<ReturnType> {
-    constructor(query: ApiQuery);
-    protected parseEmptyQuery(): ReturnType;
-    protected parseSubQuery(): ReturnType;
-    protected parseSubFieldQuery(): ReturnType;
-    protected parseSearchQuery(): ReturnType;
-    protected parseCustomQuery(): ReturnType;
-    protected parseSimpleQuery(): ReturnType;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse'], _not: T['not']): ReturnType;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
-    private parseConditions;
-}
-export {};
+import { ApiQueryConditionLinkedTo } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryWithConditions, QueryParserBase } from '../internal';
+declare type ReturnType = boolean;
+/**
+ * @description
+ * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
+ */
+export declare class QueryLocallyMatchableParser extends QueryParserBase<ReturnType> {
+    constructor(query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery(): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery(): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse'], _not: T['not']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
+    private parseConditions;
+}
+export {};

package/dist/types/src/classes/QueryMatcher.d.ts

@@ -1,25 +1,25 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, ApiQuery, FieldMap, LinkTreeServiceInterface } from '../internal';
-export declare class QueryMatcher<ItemTypeType extends ApiEnumItemType> {
-    private linkTreeService;
-    private apiFormatter;
-    itemType: ItemTypeType;
-    fields: Partial<FieldMap<ItemTypeType>> | [Partial<FieldMap<ItemTypeType>>, Partial<FieldMap<ItemTypeType>>];
-    /**
-     * @param linkTreeService
-     * @param apiFormatter
-     * @param itemType
-     * @param fields The fields to match against, if "fields" is an array index [0] should be the new/updated values, and index [1] the cached ones
-     */
-    constructor(linkTreeService: LinkTreeServiceInterface, apiFormatter: ApiFormatter, itemType: ItemTypeType, fields: Partial<FieldMap<ItemTypeType>> | [Partial<FieldMap<ItemTypeType>>, Partial<FieldMap<ItemTypeType>>]);
-    /**
-     * @remark
-     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
-     */
-    matchQuery(query: ApiQuery): boolean | 'maybe';
-    private compareValues;
-    private matchLinkedToQuery;
-    private matchComplexQuery;
-    private matchSimpleQuery;
-    private getField;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiFormatter, ApiQuery, FieldMap, LinkTreeServiceInterface } from '../internal';
+export declare class QueryMatcher<ItemTypeType extends ApiEnumItemType> {
+    private linkTreeService;
+    private apiFormatter;
+    itemType: ItemTypeType;
+    fields: Partial<FieldMap<ItemTypeType>> | [Partial<FieldMap<ItemTypeType>>, Partial<FieldMap<ItemTypeType>>];
+    /**
+     * @param linkTreeService
+     * @param apiFormatter
+     * @param itemType
+     * @param fields The fields to match against, if "fields" is an array index [0] should be the new/updated values, and index [1] the cached ones
+     */
+    constructor(linkTreeService: LinkTreeServiceInterface, apiFormatter: ApiFormatter, itemType: ItemTypeType, fields: Partial<FieldMap<ItemTypeType>> | [Partial<FieldMap<ItemTypeType>>, Partial<FieldMap<ItemTypeType>>]);
+    /**
+     * @remark
+     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
+     */
+    matchQuery(query: ApiQuery): boolean | 'maybe';
+    private compareValues;
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
+    private getField;
+}

package/dist/types/src/classes/QueryParser.d.ts

@@ -1,25 +1,25 @@
-import { ApiQuery as BackendApiQuery, ApiQueryConditionInShort, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, QueryParserBase } from '../internal';
-export declare enum CONSTANTS {
-    OBJ = 0,
-    STR = 1,
-    SEP = ":"
-}
-declare type ReturnType = [BackendApiQuery, string];
-export declare class QueryParser extends QueryParserBase<ReturnType> {
-    constructor(query: ApiQuery);
-    protected parseEmptyQuery(): ReturnType;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query'], not?: T['not']): ReturnType;
-    protected parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], itemType: T['itemType'], field: T['field'], query: T['query'], not?: T['not']): ReturnType;
-    protected parseSearchQuery(value: any, not?: boolean): ReturnType;
-    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): ReturnType;
-    protected parseCustomParameters(parameters: any): ReturnType;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionInShort<any, any>>(key: T['key'], value: T['value'], comparator: T['comparator'], not?: T['not']): ReturnType;
-    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): ReturnType;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions'], operator?: T['operator'], not?: T['not']): ReturnType;
-    private parseConditions;
-    private formatValue;
-    private processValue;
-    private compareParsedQueries;
-}
-export {};
+import { ApiQuery as BackendApiQuery, ApiQueryConditionInShort, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, QueryParserBase } from '../internal';
+export declare enum CONSTANTS {
+    OBJ = 0,
+    STR = 1,
+    SEP = ":"
+}
+declare type ReturnType = [BackendApiQuery, string];
+export declare class QueryParser extends QueryParserBase<ReturnType> {
+    constructor(query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query'], not?: T['not']): ReturnType;
+    protected parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], itemType: T['itemType'], field: T['field'], query: T['query'], not?: T['not']): ReturnType;
+    protected parseSearchQuery(value: any, not?: boolean): ReturnType;
+    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): ReturnType;
+    protected parseCustomParameters(parameters: any): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionInShort<any, any>>(key: T['key'], value: T['value'], comparator: T['comparator'], not?: T['not']): ReturnType;
+    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions'], operator?: T['operator'], not?: T['not']): ReturnType;
+    private parseConditions;
+    private formatValue;
+    private processValue;
+    private compareParsedQueries;
+}
+export {};

package/dist/types/src/classes/QueryParserBase.d.ts

@@ -1,20 +1,20 @@
-import { ApiQueryConditionCustom, ApiQueryConditionLinkedTo, ApiQueryConditionSearch, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions } from '../internal';
-export declare abstract class QueryParserBase<ReturnType extends any> {
-    protected query: ApiQuery;
-    protected constructor(query: ApiQuery);
-    parse(query?: ApiQuery): ReturnType;
-    protected abstract parseEmptyQuery(): ReturnType;
-    protected abstract parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query'], not: T['not'], queryPart: T): ReturnType;
-    protected abstract parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], itemType: T['itemType'], field: T['field'], query: T['query'], not: T['not'], queryPart: T): ReturnType;
-    protected abstract parseSearchQuery<T extends ApiQueryConditionSearch>(value: T['search'], not: T['not'], queryPart: T): ReturnType;
-    protected abstract parseCustomQuery<T extends ApiQueryConditionCustom>(custom: T['custom'], parameters: T['parameters'], not: T['not'], queryPart: T): ReturnType;
-    protected abstract parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key'], value: T['value'], comparator: T['comparator'], not: T['not'], queryPart: T): ReturnType;
-    protected abstract parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], reverse: T['reverse'], not: T['not'], queryPart: T): ReturnType;
-    protected abstract parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions'], operator: T['operator'], not: T['not'], queryPart: T): ReturnType;
-    protected isLinkedTo(query: ApiQuery): query is ApiQueryConditionLinkedTo;
-    protected isCustom(query: ApiQuery): query is ApiQueryConditionCustom;
-    protected isSearch(query: ApiQuery): query is ApiQueryConditionSearch;
-    protected isQueryWithConditions(query: ApiQuery): query is ApiQueryWithConditions;
-    protected isSub(query: ApiQuery): query is ApiQueryConditionSubQuery;
-}
+import { ApiQueryConditionCustom, ApiQueryConditionLinkedTo, ApiQueryConditionSearch, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions } from '../internal';
+export declare abstract class QueryParserBase<ReturnType extends any> {
+    protected query: ApiQuery;
+    protected constructor(query: ApiQuery);
+    parse(query?: ApiQuery): ReturnType;
+    protected abstract parseEmptyQuery(): ReturnType;
+    protected abstract parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query'], not: T['not'], queryPart: T): ReturnType;
+    protected abstract parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], itemType: T['itemType'], field: T['field'], query: T['query'], not: T['not'], queryPart: T): ReturnType;
+    protected abstract parseSearchQuery<T extends ApiQueryConditionSearch>(value: T['search'], not: T['not'], queryPart: T): ReturnType;
+    protected abstract parseCustomQuery<T extends ApiQueryConditionCustom>(custom: T['custom'], parameters: T['parameters'], not: T['not'], queryPart: T): ReturnType;
+    protected abstract parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key'], value: T['value'], comparator: T['comparator'], not: T['not'], queryPart: T): ReturnType;
+    protected abstract parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], reverse: T['reverse'], not: T['not'], queryPart: T): ReturnType;
+    protected abstract parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions'], operator: T['operator'], not: T['not'], queryPart: T): ReturnType;
+    protected isLinkedTo(query: ApiQuery): query is ApiQueryConditionLinkedTo;
+    protected isCustom(query: ApiQuery): query is ApiQueryConditionCustom;
+    protected isSearch(query: ApiQuery): query is ApiQueryConditionSearch;
+    protected isQueryWithConditions(query: ApiQuery): query is ApiQueryWithConditions;
+    protected isSub(query: ApiQuery): query is ApiQueryConditionSubQuery;
+}

package/dist/types/src/classes/QueryParserIdUpdater.d.ts

@@ -1,17 +1,17 @@
-import { ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap, QueryParserBase } from '../internal';
-declare type ReturnType = boolean;
-export declare class QueryParserIdUpdater extends QueryParserBase<ReturnType> {
-    private itemIdConversionMap;
-    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
-    protected parseEmptyQuery(): ReturnType;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
-    protected parseSubFieldQuery(): ReturnType;
-    protected parseSearchQuery(): ReturnType;
-    protected parseCustomQuery(): ReturnType;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionIn>(_key: T['key'], value: T['value'], comparator: T['comparator'], _not: T['not'], queryPart: T): ReturnType;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): ReturnType;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
-    private parseConditions;
-}
-export {};
+import { ApiQueryConditionIn, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap, QueryParserBase } from '../internal';
+declare type ReturnType = boolean;
+export declare class QueryParserIdUpdater extends QueryParserBase<ReturnType> {
+    private itemIdConversionMap;
+    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator | ApiQueryConditionIn>(_key: T['key'], value: T['value'], comparator: T['comparator'], _not: T['not'], queryPart: T): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
+    private parseConditions;
+}
+export {};

package/dist/types/src/classes/QueryService.d.ts

@@ -1,12 +1,12 @@
-import { ApiEnumItemType, ApiQueryConditionIn, ItemId } from '@rentman/backend-types';
-import { ApiQuery, EntryParentNull, KeyService } from '../internal';
-export declare class QueryService {
-    private keyService;
-    constructor(keyService: KeyService);
-    containsLinkedTo(query: ApiQuery, matchItemType: ApiEnumItemType, matchItemId: ItemId): boolean;
-    containsLocalId(query: ApiQuery): boolean;
-    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
-    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
-    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
-    createNotIn(idArray: ItemId[]): ApiQueryConditionIn;
-}
+import { ApiEnumItemType, ApiQueryConditionIn, ItemId } from '@rentman/backend-types';
+import { ApiQuery, EntryParentNull, KeyService } from '../internal';
+export declare class QueryService {
+    private keyService;
+    constructor(keyService: KeyService);
+    containsLinkedTo(query: ApiQuery, matchItemType: ApiEnumItemType, matchItemId: ItemId): boolean;
+    containsLocalId(query: ApiQuery): boolean;
+    addAndCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addOrCondition(query: ApiQuery, condition: ApiQuery): ApiQuery;
+    addParentCondition(query: ApiQuery, parent: EntryParentNull): ApiQuery;
+    createNotIn(idArray: ItemId[]): ApiQueryConditionIn;
+}

package/dist/types/src/classes/RequestBuffer.d.ts

@@ -1,26 +1,26 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiQuery, ApiRequestColumns, ApiRequestService, ApiResponseProcessor, ChangesDeltaFactory, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, RequestColumnsTuple, ServerCache } from '../internal';
-export declare type RequestBufferResponse<ItemTypeType extends ApiEnumItemType = any> = ApiResponseProcessor<ItemTypeType>;
-export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = any> {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private changesDeltaFactory;
-    private serverCache;
-    private itemType;
-    private deferred;
-    private requestColumnExpansion;
-    private singleItemIds;
-    private queries;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemTypeType);
-    containsId(itemId: ItemId): boolean;
-    containsQuery(queryString: string): boolean;
-    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    addQuery(query: [ApiQuery, string], requestColumnsTuple: RequestColumnsTuple): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    isPrivateBuffer(): boolean;
-    getFirstQueryString(): string | undefined;
-    private hasMultipleQueries;
-    private createAggregateQuery;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiQuery, ApiRequestColumns, ApiRequestService, ApiResponseProcessor, ChangesDeltaFactory, PromiseInterface, PromiseLibraryInterface, RequestColumnExpansionFactory, RequestColumnsTuple, ServerCache } from '../internal';
+export declare type RequestBufferResponse<ItemTypeType extends ApiEnumItemType = any> = ApiResponseProcessor<ItemTypeType>;
+export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = any> {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private changesDeltaFactory;
+    private serverCache;
+    private itemType;
+    private deferred;
+    private requestColumnExpansion;
+    private singleItemIds;
+    private queries;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, changesDeltaFactory: ChangesDeltaFactory, serverCache: ServerCache, itemType: ItemTypeType);
+    containsId(itemId: ItemId): boolean;
+    containsQuery(queryString: string): boolean;
+    addSingleItem(itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    addQuery(query: [ApiQuery, string], requestColumnsTuple: RequestColumnsTuple): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    isPrivateBuffer(): boolean;
+    getFirstQueryString(): string | undefined;
+    private hasMultipleQueries;
+    private createAggregateQuery;
+}

package/dist/types/src/classes/RequestBufferManager.d.ts

@@ -1,21 +1,21 @@
-import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
-import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, RequestColumnsTuple, ServerCache } from '../internal';
-export declare class RequestBufferManager {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private keyService;
-    private changesDeltaFactory;
-    private pendingBufferMap;
-    private pendingTrueBufferMap;
-    private pendingPrivateBufferMap;
-    private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
-    setServerCache(serverCache: ServerCache): void;
-    fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumnsTuple: RequestColumnsTuple, usePrivateBuffer: boolean): PromiseInterface<RequestBufferResponse>;
-    private constructPrivateBuffer;
-    private constructBuffer;
-    private _constructBuffer;
-}
+import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, ChangesDeltaFactory, KeyService, PromiseInterface, PromiseLibraryInterface, RequestBufferResponse, RequestColumnExpansionFactory, RequestColumnsTuple, ServerCache } from '../internal';
+export declare class RequestBufferManager {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private keyService;
+    private changesDeltaFactory;
+    private pendingBufferMap;
+    private pendingTrueBufferMap;
+    private pendingPrivateBufferMap;
+    private serverCache;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
+    setServerCache(serverCache: ServerCache): void;
+    fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], requestColumnsTuple: RequestColumnsTuple, usePrivateBuffer: boolean): PromiseInterface<RequestBufferResponse>;
+    private constructPrivateBuffer;
+    private constructBuffer;
+    private _constructBuffer;
+}

package/dist/types/src/classes/RequestColumnExpansion.d.ts

@@ -1,13 +1,13 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiRequestColumnMap, ApiRequestColumns, ColumnSet, ColumnUtil, RequestColumnsTuple } from '../internal';
-export declare class RequestColumnExpansion {
-    private columnUtil;
-    private columns;
-    private columnSetIdMap;
-    private requestColumnSetIdMap;
-    constructor(columnUtil: ColumnUtil);
-    expandWithRequestColumnsTuple(itemType: ApiEnumItemType, requestColumnsTuple: RequestColumnsTuple): void;
-    expandWithColumnSet(columnSet: ColumnSet): void;
-    expandWithRequestColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns): void;
-    get(): ApiRequestColumnMap;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestColumns, ColumnSet, ColumnUtil, RequestColumnsTuple } from '../internal';
+export declare class RequestColumnExpansion {
+    private columnUtil;
+    private columns;
+    private columnSetIdMap;
+    private requestColumnSetIdMap;
+    constructor(columnUtil: ColumnUtil);
+    expandWithRequestColumnsTuple(itemType: ApiEnumItemType, requestColumnsTuple: RequestColumnsTuple): void;
+    expandWithColumnSet(columnSet: ColumnSet): void;
+    expandWithRequestColumns(itemType: ApiEnumItemType, requestColumns: ApiRequestColumns): void;
+    get(): ApiRequestColumnMap;
+}

package/dist/types/src/classes/RequestColumnsOperationsCache.d.ts

@@ -1,46 +1,46 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestColumnArray, ApiRequestColumns, ColumnCache, ColumnSet, ColumnUtil, RequestColumnsTuple } from '../internal';
-declare type RequestColumnSetMergeResult = {
-    merged: RequestColumnsTuple;
-    difference: RequestColumnsTuple;
-};
-declare type AggregateColumnsTuple = {
-    readonly object: ApiRequestColumnArray;
-    readonly string: string;
-};
-/**
- * @description This class caches the results of frequently performed operations on request columns:
- * - Merging;
- * - Testing whether all columns of one column set are present in another (which is mainly done by merging and checking
- * the difference);
- * - Creating hashes (IDs) for sets of request columns.
- */
-export declare class RequestColumnsOperationsCache<ItemTypeType extends ApiEnumItemType> {
-    readonly itemType: ItemTypeType;
-    private columnUtil;
-    private columnCache;
-    private readonly requestColumnsTuple;
-    private aggregateColumnsTuple?;
-    private expandedRequestColumnsTuple?;
-    private columnsMergedWithTupleMap;
-    private expandedColumnsMergedWithTupleMap;
-    private setContainsAllColumnsMap;
-    private setContainsAllExpandedColumnsMap;
-    constructor(itemType: ItemTypeType, columnUtil: ColumnUtil, columnCache: ColumnCache, requestColumns: ApiRequestColumns);
-    getRequestColumnsTuple(transactionCache: AbstractCache): RequestColumnsTuple;
-    getAggregateColumns(): AggregateColumnsTuple;
-    hasAggregateColumns(): boolean;
-    /**
-     *
-     * @param requestColumnsTuple
-     * @param transactionCache - When in the server cache, we'll include the columns required for delete
-     * relations and the query matcher in the operation.
-     */
-    getColumnsMergedWithTuple(requestColumnsTuple: RequestColumnsTuple, transactionCache: AbstractCache): RequestColumnSetMergeResult;
-    tupleContainsAllColumns(requestColumnsTuple: RequestColumnsTuple, transactionCache: AbstractCache): boolean;
-    setContainsAllColumns(columnSet: ColumnSet<ItemTypeType>, transactionCache: AbstractCache): boolean;
-    private mergeColumnsWithTuple;
-    private extractAggregateColumns;
-    private createRequestColumnsTuple;
-}
-export {};
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestColumnArray, ApiRequestColumns, ColumnCache, ColumnSet, ColumnUtil, RequestColumnsTuple } from '../internal';
+declare type RequestColumnSetMergeResult = {
+    merged: RequestColumnsTuple;
+    difference: RequestColumnsTuple;
+};
+declare type AggregateColumnsTuple = {
+    readonly object: ApiRequestColumnArray;
+    readonly string: string;
+};
+/**
+ * @description This class caches the results of frequently performed operations on request columns:
+ * - Merging;
+ * - Testing whether all columns of one column set are present in another (which is mainly done by merging and checking
+ * the difference);
+ * - Creating hashes (IDs) for sets of request columns.
+ */
+export declare class RequestColumnsOperationsCache<ItemTypeType extends ApiEnumItemType> {
+    readonly itemType: ItemTypeType;
+    private columnUtil;
+    private columnCache;
+    private readonly requestColumnsTuple;
+    private aggregateColumnsTuple?;
+    private expandedRequestColumnsTuple?;
+    private columnsMergedWithTupleMap;
+    private expandedColumnsMergedWithTupleMap;
+    private setContainsAllColumnsMap;
+    private setContainsAllExpandedColumnsMap;
+    constructor(itemType: ItemTypeType, columnUtil: ColumnUtil, columnCache: ColumnCache, requestColumns: ApiRequestColumns);
+    getRequestColumnsTuple(transactionCache: AbstractCache): RequestColumnsTuple;
+    getAggregateColumns(): AggregateColumnsTuple;
+    hasAggregateColumns(): boolean;
+    /**
+     *
+     * @param requestColumnsTuple
+     * @param transactionCache - When in the server cache, we'll include the columns required for delete
+     * relations and the query matcher in the operation.
+     */
+    getColumnsMergedWithTuple(requestColumnsTuple: RequestColumnsTuple, transactionCache: AbstractCache): RequestColumnSetMergeResult;
+    tupleContainsAllColumns(requestColumnsTuple: RequestColumnsTuple, transactionCache: AbstractCache): boolean;
+    setContainsAllColumns(columnSet: ColumnSet<ItemTypeType>, transactionCache: AbstractCache): boolean;
+    private mergeColumnsWithTuple;
+    private extractAggregateColumns;
+    private createRequestColumnsTuple;
+}
+export {};

package/dist/types/src/classes/SocketMessageHandler.d.ts

@@ -1,34 +1,34 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, ApiRequestService, CachedQueryItem, ChangesDeltaFactory, ErrorHandlerInterface, PromiseLibraryInterface, QueryMatcherFactory, RequestBufferManager, RequestColumnExpansionFactory, SocketMessage, TransactionCacheFactory } from '../internal';
-export declare type CachedQueryMatchingResult<ItemTypeType extends ApiEnumItemType> = {
-    fitting: CachedQueryItem<ItemTypeType>[];
-    notfitting: CachedQueryItem<ItemTypeType>[];
-    maybe: CachedQueryItem<ItemTypeType>[];
-};
-export declare class SocketMessageHandler {
-    private requestBufferManager;
-    private changesDeltaFactory;
-    private apiFormatter;
-    private errorHandler;
-    private transactionCacheFactory;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    private apiRequestService;
-    private queryMatcherFactory;
-    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory);
-    onMessageReceived(message: SocketMessage): any;
-    private formatMessageValues;
-    private getCollectionsWithLimitByItemType;
-    /**
-     * @description
-     * When an item is created or updated, we should check if it fits in any of the cached queries (using the values provided by the socket message)
-     * If we think it fits (or maybe) we should fetch the complete item with the superset of columns (the socket message might not have all values)
-     */
-    private processMessage;
-    private processFunctionChangesResolve;
-    private isFunctionChangesResolveMessage;
-    private handleCreate;
-    private handleUpdate;
-    private handleDelete;
-    private handleLinkMove;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiFormatter, ApiRequestService, CachedQueryItem, ChangesDeltaFactory, ErrorHandlerInterface, PromiseLibraryInterface, QueryMatcherFactory, RequestBufferManager, RequestColumnExpansionFactory, SocketMessage, TransactionCacheFactory } from '../internal';
+export declare type CachedQueryMatchingResult<ItemTypeType extends ApiEnumItemType> = {
+    fitting: CachedQueryItem<ItemTypeType>[];
+    notfitting: CachedQueryItem<ItemTypeType>[];
+    maybe: CachedQueryItem<ItemTypeType>[];
+};
+export declare class SocketMessageHandler {
+    private requestBufferManager;
+    private changesDeltaFactory;
+    private apiFormatter;
+    private errorHandler;
+    private transactionCacheFactory;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private apiRequestService;
+    private queryMatcherFactory;
+    constructor(requestBufferManager: RequestBufferManager, changesDeltaFactory: ChangesDeltaFactory, apiFormatter: ApiFormatter, errorHandler: ErrorHandlerInterface, transactionCacheFactory: TransactionCacheFactory, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, queryMatcherFactory: QueryMatcherFactory);
+    onMessageReceived(message: SocketMessage): any;
+    private formatMessageValues;
+    private getCollectionsWithLimitByItemType;
+    /**
+     * @description
+     * When an item is created or updated, we should check if it fits in any of the cached queries (using the values provided by the socket message)
+     * If we think it fits (or maybe) we should fetch the complete item with the superset of columns (the socket message might not have all values)
+     */
+    private processMessage;
+    private processFunctionChangesResolve;
+    private isFunctionChangesResolveMessage;
+    private handleCreate;
+    private handleUpdate;
+    private handleDelete;
+    private handleLinkMove;
+}