@rentman/rm-core 7.0.4 → 7.0.6

package/dist/types/classes/LockService.d.ts

@@ -1,32 +1,32 @@
-import { ApiRequestService, KeyService } from '../classes';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemEntry } from '../models';
-import { ItemId, PromiseInterface } from '../types';
-export declare type LockToken = {
-    isForeign: false;
-    id: number;
-    token: string;
-} | {
-    isForeign: true;
-    message: string;
-};
-export declare class LockService {
-    private apiRequestService;
-    private errorHandler;
-    private keyService;
-    private promiseService;
-    private lockItems;
-    private promises;
-    constructor(apiRequestService: ApiRequestService, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
-    getLocks(): LockService['lockItems'];
-    hasLock(lockTokenId: ItemId): boolean;
-    isLocked(itemEntry: ItemEntry<any>): boolean;
-    getMessage(itemEntry: ItemEntry<any>): undefined | string;
-    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
-    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
-    clearLock(itemEntry: ItemEntry<any>): boolean;
-    private requestLock;
-    private fetchCachedLock;
-    private getValue;
-    private setValue;
-}
+import { ApiRequestService, KeyService } from '../classes';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemEntry } from '../models';
+import { ItemId, PromiseInterface } from '../types';
+export declare type LockToken = {
+    isForeign: false;
+    id: number;
+    token: string;
+} | {
+    isForeign: true;
+    message: string;
+};
+export declare class LockService {
+    private apiRequestService;
+    private errorHandler;
+    private keyService;
+    private promiseService;
+    private lockItems;
+    private promises;
+    constructor(apiRequestService: ApiRequestService, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface);
+    getLocks(): LockService['lockItems'];
+    hasLock(lockTokenId: ItemId): boolean;
+    isLocked(itemEntry: ItemEntry<any>): boolean;
+    getMessage(itemEntry: ItemEntry<any>): undefined | string;
+    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry<any>): boolean;
+    private requestLock;
+    private fetchCachedLock;
+    private getValue;
+    private setValue;
+}

package/dist/types/classes/ModuleChangesCompilation.d.ts

@@ -1,18 +1,18 @@
-import { ApiRequestItemMap, ItemId, ItemType } from '../types';
-import { TransactionCache } from './cache/transaction/TransactionCache';
-export declare type ModuleChangesCompilationResult = {
-    itemType: ItemType;
-    itemId: ItemId;
-    items: ApiRequestItemMap;
-};
-export declare class ModuleChangesCompilation {
-    private transaction;
-    parentMap: any;
-    destination: ApiRequestItemMap;
-    constructor(transaction: TransactionCache);
-    process(): ModuleChangesCompilationResult;
-    private createParentMap;
-    private processItems;
-    private processItem;
-    private getItemsByParent;
-}
+import { ApiRequestItemMap, ItemId, ItemType } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
+export declare type ModuleChangesCompilationResult = {
+    itemType: ItemType;
+    itemId: ItemId;
+    items: ApiRequestItemMap;
+};
+export declare class ModuleChangesCompilation {
+    private transaction;
+    parentMap: any;
+    destination: ApiRequestItemMap;
+    constructor(transaction: TransactionCache);
+    process(): ModuleChangesCompilationResult;
+    private createParentMap;
+    private processItems;
+    private processItem;
+    private getItemsByParent;
+}

package/dist/types/classes/QueryColumnExtractor.d.ts

@@ -1,20 +1,20 @@
-import { ApiQuery, ApiRequestColumn, ItemType } from '../types';
-import { ColumnUtil } from './ColumnUtil';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare class QueryColumnExtractor extends QueryParserBase<ApiRequestColumn[]> {
-    private columnUtil;
-    private itemType;
-    constructor(columnUtil: ColumnUtil, itemType: ItemType, query: ApiQuery);
-    protected parseEmptyQuery(): never[];
-    protected parseSubQuery(key: string, subQuery: object, _not?: boolean): {
-        [x: string]: ApiRequestColumn[];
-    }[];
-    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): never[];
-    protected parseSearchQuery(_value: any, _not: boolean): never[];
-    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): never[];
-    protected parseSimpleQuery(key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): string[];
-    protected parseLinkedToQuery(linkedTo: any, _query?: ApiQuery, _reverse?: boolean, _not?: boolean): ApiRequestColumn[];
-    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): any;
-    private parseConditions;
-}
+import { ApiQuery, ApiRequestColumn, ItemType } from '../types';
+import { ColumnUtil } from './ColumnUtil';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryColumnExtractor extends QueryParserBase<ApiRequestColumn[]> {
+    private columnUtil;
+    private itemType;
+    constructor(columnUtil: ColumnUtil, itemType: ItemType, query: ApiQuery);
+    protected parseEmptyQuery(): never[];
+    protected parseSubQuery(key: string, subQuery: object, _not?: boolean): {
+        [x: string]: ApiRequestColumn[];
+    }[];
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): never[];
+    protected parseSearchQuery(_value: any, _not: boolean): never[];
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): never[];
+    protected parseSimpleQuery(key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): string[];
+    protected parseLinkedToQuery(linkedTo: any, _query?: ApiQuery, _reverse?: boolean, _not?: boolean): ApiRequestColumn[];
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): any;
+    private parseConditions;
+}

package/dist/types/classes/QueryContainsLocalIdParser.d.ts

@@ -1,17 +1,17 @@
-import { ApiQuery, ItemType } from '../types';
-import { KeyService } from './KeyService';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare class QueryContainsLocalIdParser extends QueryParserBase<boolean> {
-    private keyService;
-    constructor(keyService: KeyService, query: any);
-    protected parseEmptyQuery(): boolean;
-    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): boolean;
-    protected parseSubFieldQuery(_key: string, _itemType: ItemType, field: string, query: ApiQuery, _not: boolean): boolean;
-    protected parseSearchQuery(_value: any, _not: boolean): boolean;
-    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
-    protected parseSimpleQuery(_key: string, value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
-    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): boolean;
-    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
-    private parseConditions;
-}
+import { ApiQuery, ItemType } from '../types';
+import { KeyService } from './KeyService';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryContainsLocalIdParser extends QueryParserBase<boolean> {
+    private keyService;
+    constructor(keyService: KeyService, query: any);
+    protected parseEmptyQuery(): boolean;
+    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): boolean;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, field: string, query: ApiQuery, _not: boolean): boolean;
+    protected parseSearchQuery(_value: any, _not: boolean): boolean;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
+    protected parseSimpleQuery(_key: string, value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
+    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): boolean;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
+    private parseConditions;
+}

package/dist/types/classes/QueryLinkedToParser.d.ts

@@ -1,16 +1,16 @@
-import { ApiQuery, ItemType } from '../types';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare class QueryLinkedToParser extends QueryParserBase<boolean> {
-    private callback;
-    constructor(callback: (linkedTo: ItemType, query: ApiQuery) => boolean, query: ApiQuery);
-    protected parseEmptyQuery(): boolean;
-    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): boolean;
-    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): boolean;
-    protected parseSearchQuery(_value: any, _not: boolean): boolean;
-    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
-    protected parseSimpleQuery(_key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
-    protected parseLinkedToQuery(linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, not?: boolean): boolean;
-    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
-    private parseConditions;
-}
+import { ApiQuery, ItemType } from '../types';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryLinkedToParser extends QueryParserBase<boolean> {
+    private callback;
+    constructor(callback: (linkedTo: ItemType, query: ApiQuery) => boolean, query: ApiQuery);
+    protected parseEmptyQuery(): boolean;
+    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): boolean;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): boolean;
+    protected parseSearchQuery(_value: any, _not: boolean): boolean;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
+    protected parseSimpleQuery(_key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
+    protected parseLinkedToQuery(linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, not?: boolean): boolean;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
+    private parseConditions;
+}

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

@@ -1,19 +1,19 @@
-import { ApiQuery, ItemType } from '../types';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-/**
- * @description
- * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
- */
-export declare class QueryLocallyMatchableParser extends QueryParserBase<boolean> {
-    constructor(query: ApiQuery);
-    protected parseEmptyQuery(): boolean;
-    protected parseSubQuery(_key: string, _subQuery: object, _not?: boolean): boolean;
-    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): boolean;
-    protected parseSearchQuery(_value: any, _not: boolean): boolean;
-    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
-    protected parseSimpleQuery(_key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
-    protected parseLinkedToQuery(_linkedTo: ItemType, _query?: ApiQuery, _reverse?: boolean, _not?: boolean): boolean;
-    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
-    private parseConditions;
-}
+import { ApiQuery, ItemType } from '../types';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+/**
+ * @description
+ * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
+ */
+export declare class QueryLocallyMatchableParser extends QueryParserBase<boolean> {
+    constructor(query: ApiQuery);
+    protected parseEmptyQuery(): boolean;
+    protected parseSubQuery(_key: string, _subQuery: object, _not?: boolean): boolean;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): boolean;
+    protected parseSearchQuery(_value: any, _not: boolean): boolean;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): boolean;
+    protected parseSimpleQuery(_key: string, _value: any, _comparator?: COMPARATORS_TYPE, _not?: boolean): boolean;
+    protected parseLinkedToQuery(_linkedTo: ItemType, _query?: ApiQuery, _reverse?: boolean, _not?: boolean): boolean;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): boolean;
+    private parseConditions;
+}

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

@@ -1,18 +1,18 @@
-import { ApiFormatter } from '../classes';
-import { ApiQuery, EntryParentNull, FieldMap, ItemType } from '../types';
-export declare class QueryMatcher {
-    private apiFormatter;
-    itemType: ItemType;
-    fields: FieldMap;
-    parent: EntryParentNull;
-    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
-    private compareValues;
-    /**
-     * @remark
-     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
-     */
-    matchQuery(query: ApiQuery): boolean | 'maybe';
-    private matchLinkedToQuery;
-    private matchComplexQuery;
-    private matchSimpleQuery;
-}
+import { ApiFormatter } from '../classes';
+import { ApiQuery, EntryParentNull, FieldMap, ItemType } from '../types';
+export declare class QueryMatcher {
+    private apiFormatter;
+    itemType: ItemType;
+    fields: FieldMap;
+    parent: EntryParentNull;
+    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
+    private compareValues;
+    /**
+     * @remark
+     * When changing this code also change {@link QueryLocallyMatchableParser QueryLocallyMatchableParser}
+     */
+    matchQuery(query: ApiQuery): boolean | 'maybe';
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
+}

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

@@ -1,24 +1,24 @@
-import { ApiQuery } from '../types';
-import { COMPARATORS, OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare enum CONSTANTS {
-    OBJ = 0,
-    STR = 1,
-    SEP = ":"
-}
-export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
-export declare class QueryParser extends QueryParserBase<[object, string]> {
-    constructor(query: ApiQuery);
-    protected parseEmptyQuery(): [object, string];
-    protected parseSubQuery(key: string, subQuery: object, not?: boolean): [object, string];
-    protected parseSubFieldQuery(key: string | undefined, itemType: string | undefined, field: string | undefined, query: ApiQuery, not?: boolean): [object, string];
-    protected parseSearchQuery(value: any, not?: boolean): [object, string];
-    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): [object, string];
-    protected parseCustomParameters(parameters: any): [object, string];
-    protected parseSimpleQuery(key: string, value: any, comparator?: COMPARATORS_TYPE, not?: boolean): [object, string];
-    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): [object, string];
-    protected parseComplexQuery(conditions: any[], operator?: OPERATORS_TYPE, not?: boolean): [object, string];
-    private parseConditions;
-    private formatValue;
-    private processValue;
-    private compareParsedQueries;
-}
+import { ApiQuery } from '../types';
+import { COMPARATORS, OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare enum CONSTANTS {
+    OBJ = 0,
+    STR = 1,
+    SEP = ":"
+}
+export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
+export declare class QueryParser extends QueryParserBase<[object, string]> {
+    constructor(query: ApiQuery);
+    protected parseEmptyQuery(): [object, string];
+    protected parseSubQuery(key: string, subQuery: object, not?: boolean): [object, string];
+    protected parseSubFieldQuery(key: string | undefined, itemType: string | undefined, field: string | undefined, query: ApiQuery, not?: boolean): [object, string];
+    protected parseSearchQuery(value: any, not?: boolean): [object, string];
+    protected parseCustomQuery(custom: string, parameters: any, not?: boolean): [object, string];
+    protected parseCustomParameters(parameters: any): [object, string];
+    protected parseSimpleQuery(key: string, value: any, comparator?: COMPARATORS_TYPE, not?: boolean): [object, string];
+    protected parseLinkedToQuery(linkedTo: any, query?: ApiQuery, reverse?: boolean, not?: boolean): [object, string];
+    protected parseComplexQuery(conditions: any[], operator?: OPERATORS_TYPE, not?: boolean): [object, string];
+    private parseConditions;
+    private formatValue;
+    private processValue;
+    private compareParsedQueries;
+}

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

@@ -1,29 +1,29 @@
-import { ApiQuery, ItemType } from '../types';
-export declare enum OPERATORS {
-    OR = "OR",
-    AND = "AND"
-}
-export declare type OPERATORS_TYPE = 'OR' | 'AND' | 'or' | 'and' | OPERATORS;
-export declare enum COMPARATORS {
-    EQUALS = "=",
-    NOT_EQUALS = "!=",
-    LESS_THAN = "<",
-    MORE_THAN = ">",
-    LESS_OR_EQUAL_THAN = "<=",
-    EQUAL_OR_MORE_THAN = ">=",
-    IN = "IN"
-}
-export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
-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(key: string, subQuery: object, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseSearchQuery(value: any, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean, queryPart: ApiQuery): ReturnType;
-    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
-}
+import { ApiQuery, ItemType } from '../types';
+export declare enum OPERATORS {
+    OR = "OR",
+    AND = "AND"
+}
+export declare type OPERATORS_TYPE = 'OR' | 'AND' | 'or' | 'and' | OPERATORS;
+export declare enum COMPARATORS {
+    EQUALS = "=",
+    NOT_EQUALS = "!=",
+    LESS_THAN = "<",
+    MORE_THAN = ">",
+    LESS_OR_EQUAL_THAN = "<=",
+    EQUAL_OR_MORE_THAN = ">=",
+    IN = "IN"
+}
+export declare type COMPARATORS_TYPE = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'IN' | COMPARATORS;
+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(key: string, subQuery: object, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSearchQuery(value: any, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean, queryPart: ApiQuery): ReturnType;
+    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean, queryPart: ApiQuery): ReturnType;
+}

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

@@ -1,16 +1,16 @@
-import { ApiQuery, ItemIdConversionMap, ItemType } from '../types';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
-export declare class QueryParserIdUpdater extends QueryParserBase<void> {
-    private itemIdConversionMap;
-    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
-    protected parseEmptyQuery(): void;
-    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): void;
-    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): void;
-    protected parseSearchQuery(_value: any, _not: boolean): void;
-    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): void;
-    protected parseSimpleQuery(_key: string, value: any, _comparator: COMPARATORS_TYPE, _not: boolean, queryPart: ApiQuery): void;
-    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): void;
-    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): void;
-    private parseConditions;
-}
+import { ApiQuery, ItemIdConversionMap, ItemType } from '../types';
+import { COMPARATORS_TYPE } from './QueryParser';
+import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+export declare class QueryParserIdUpdater extends QueryParserBase<void> {
+    private itemIdConversionMap;
+    constructor(itemIdConversionMap: ItemIdConversionMap, query: ApiQuery);
+    protected parseEmptyQuery(): void;
+    protected parseSubQuery(_key: string, subQuery: object, _not?: boolean): void;
+    protected parseSubFieldQuery(_key: string, _itemType: ItemType, _field: string, _query: ApiQuery, _not: boolean): void;
+    protected parseSearchQuery(_value: any, _not: boolean): void;
+    protected parseCustomQuery(_custom: string, _parameters: any, _not?: boolean): void;
+    protected parseSimpleQuery(_key: string, value: any, _comparator: COMPARATORS_TYPE, _not: boolean, queryPart: ApiQuery): void;
+    protected parseLinkedToQuery(_linkedTo: ItemType, query?: ApiQuery, _reverse?: boolean, _not?: boolean): void;
+    protected parseComplexQuery(conditions: any[], _operator?: OPERATORS_TYPE, _not?: boolean): void;
+    private parseConditions;
+}

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

@@ -1,18 +1,18 @@
-import { ApiQuery, EntryParentNull, ItemId, ItemType } from '../types';
-import { KeyService } from './KeyService';
-import { COMPARATORS } from './QueryParserBase';
-export declare class QueryService {
-    private keyService;
-    constructor(keyService: KeyService);
-    containsLinkedTo(query: ApiQuery, matchItemType: ItemType, 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[]): {
-        comparator: COMPARATORS;
-        key: string;
-        value: number[];
-        not: boolean;
-    };
-}
+import { ApiQuery, EntryParentNull, ItemId, ItemType } from '../types';
+import { KeyService } from './KeyService';
+import { COMPARATORS } from './QueryParserBase';
+export declare class QueryService {
+    private keyService;
+    constructor(keyService: KeyService);
+    containsLinkedTo(query: ApiQuery, matchItemType: ItemType, 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[]): {
+        comparator: COMPARATORS;
+        key: string;
+        value: number[];
+        not: boolean;
+    };
+}

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

@@ -1,28 +1,28 @@
-import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
-import { PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
-import { ApiRequestService } from './ApiRequestService';
-import { ApiResponseProcessor } from './ApiResponseProcessor';
-import { ServerCache } from './cache/server/ServerCache';
-export declare type RequestBufferResponse<ItemTypeType extends ItemType = any> = ApiResponseProcessor<ItemTypeType>;
-export declare class RequestBuffer<ItemTypeType extends ItemType = 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: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
-    private hasMultipleQueries;
-    private getFirstQueryString;
-}
+import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
+import { PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ApiResponseProcessor } from './ApiResponseProcessor';
+import { ServerCache } from './cache/server/ServerCache';
+export declare type RequestBufferResponse<ItemTypeType extends ItemType = any> = ApiResponseProcessor<ItemTypeType>;
+export declare class RequestBuffer<ItemTypeType extends ItemType = 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: [object, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
+    private hasMultipleQueries;
+    private getFirstQueryString;
+}

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

@@ -1,25 +1,25 @@
-import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
-import { PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
-import { ApiRequestService } from './ApiRequestService';
-import { ServerCache } from './cache/server/ServerCache';
-import { KeyService } from './KeyService';
-import { RequestBufferResponse } from './RequestBuffer';
-export declare class RequestBufferManager {
-    private promiseLibrary;
-    private apiRequestService;
-    private requestColumnExpansionFactory;
-    private keyService;
-    private changesDeltaFactory;
-    private pendingBufferMap;
-    private pendingTrueBufferMap;
-    private serverCache;
-    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
-    setServerCache(serverCache: ServerCache): void;
-    fetchByIds(itemType: ItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchById(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
-    requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    private constructBuffer;
-    private _constructBuffer;
-}
+import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
+import { PromiseLibraryInterface } from '../interfaces';
+import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestService } from './ApiRequestService';
+import { ServerCache } from './cache/server/ServerCache';
+import { KeyService } from './KeyService';
+import { RequestBufferResponse } from './RequestBuffer';
+export declare class RequestBufferManager {
+    private promiseLibrary;
+    private apiRequestService;
+    private requestColumnExpansionFactory;
+    private keyService;
+    private changesDeltaFactory;
+    private pendingBufferMap;
+    private pendingTrueBufferMap;
+    private serverCache;
+    constructor(promiseLibrary: PromiseLibraryInterface, apiRequestService: ApiRequestService, requestColumnExpansionFactory: RequestColumnExpansionFactory, keyService: KeyService, changesDeltaFactory: ChangesDeltaFactory);
+    setServerCache(serverCache: ServerCache): void;
+    fetchByIds(itemType: ItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchById(itemType: ItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ItemType, query: [object, string], // queryParser result
+    requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    private constructBuffer;
+    private _constructBuffer;
+}

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

@@ -1,15 +1,15 @@
-import { ColumnSet, ColumnUtil, RequestColumnMergeResult } from '../classes';
-import { ApiRequestColumns, ItemType } from '../types';
-declare type RequestColumnMap = {
-    [itemType: string]: ApiRequestColumns;
-};
-export declare class RequestColumnExpansion {
-    private columnUtil;
-    private columns;
-    private columnSetIdMap;
-    constructor(columnUtil: ColumnUtil);
-    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): RequestColumnMergeResult;
-    expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
-    get(): RequestColumnMap;
-}
-export {};
+import { ColumnSet, ColumnUtil, RequestColumnMergeResult } from '../classes';
+import { ApiRequestColumns, ItemType } from '../types';
+declare type RequestColumnMap = {
+    [itemType: string]: ApiRequestColumns;
+};
+export declare class RequestColumnExpansion {
+    private columnUtil;
+    private columns;
+    private columnSetIdMap;
+    constructor(columnUtil: ColumnUtil);
+    expandWithRequestColumns(itemType: ItemType, requestColumns: ApiRequestColumns): RequestColumnMergeResult;
+    expand<T extends ColumnSet<ItemType>>(columnSet: T): void;
+    get(): RequestColumnMap;
+}
+export {};