@rentman/rm-core 2.0.11 → 2.0.13

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

@@ -1,19 +1,19 @@
-import { ApiFormatter, CreateCompilation, KeyService } from '../classes';
-import { RequestColumnExpansionFactory } from '../factories';
-import { CreateRequestEntry, ItemType } from '../types';
-import { TransactionCache } from './cache/transaction/TransactionCache';
-export declare class CreateRequest<ItemTypeType extends ItemType> {
-    private apiFormatter;
-    private keyService;
-    private requestColumnExpansionFactory;
-    private compilation;
-    private transaction;
-    private breakupByParent;
-    requests: Array<CreateRequestEntry<ItemTypeType>>;
-    constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean);
-    finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
-    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
-    run(): CreateRequestEntry<ItemTypeType>[];
-    initializeRequest(): CreateRequestEntry<ItemTypeType>;
-    private extendRequest;
-}
+import { ApiFormatter, CreateCompilation, KeyService } from '../classes';
+import { RequestColumnExpansionFactory } from '../factories';
+import { CreateRequestEntry, ItemType } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
+export declare class CreateRequest<ItemTypeType extends ItemType> {
+    private apiFormatter;
+    private keyService;
+    private requestColumnExpansionFactory;
+    private compilation;
+    private transaction;
+    private breakupByParent;
+    requests: Array<CreateRequestEntry<ItemTypeType>>;
+    constructor(apiFormatter: ApiFormatter, keyService: KeyService, requestColumnExpansionFactory: RequestColumnExpansionFactory, compilation: CreateCompilation, transaction: TransactionCache, breakupByParent?: boolean);
+    finalizeRequest(requestResource: CreateRequestEntry<ItemTypeType>): CreateRequestEntry<ItemTypeType>;
+    setRequestParent(parentType: ItemType, requestEntry: CreateRequestEntry<ItemTypeType>): boolean;
+    run(): CreateRequestEntry<ItemTypeType>[];
+    initializeRequest(): CreateRequestEntry<ItemTypeType>;
+    private extendRequest;
+}

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

@@ -1,38 +1,38 @@
-import { ItemEntry } from '../models';
-import { EntryParent, FieldMap, ItemIdConversionMap, ItemType } from '../types';
-import { ChangesDeltaBase } from './ChangesDeltaBase';
-import { ItemEntryService } from './ItemEntryService';
-export declare type InternalCreateDelta<ItemTypeType extends ItemType = any> = {
-    entry: ItemEntry<ItemTypeType>;
-    fields: FieldMap<ItemTypeType>;
-};
-/**
- * @description
- * ChangesDelta used internally by the core
- *
- * ----------
- *
- * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the InternalChangesDelta
- * assumes 'created' entries are already existing, so it has a different format.
- *
- * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent} and {@link TransactionCache.applyChangesFromChild applyChangesFromChild}
- */
-export declare class InternalChangesDelta extends ChangesDeltaBase {
-    created: {
-        [itemEntryId: string]: InternalCreateDelta;
-    };
-    moved: {
-        [itemEntryId: number]: {
-            entry: ItemEntry;
-            to: EntryParent;
-        };
-    };
-    itemIdConversionMap: ItemIdConversionMap;
-    constructor(itemEntryService: ItemEntryService);
-    setItemCreated<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
-    /**
-     * @remark
-     * Parent fields are non-writable so we need to keep track of moved entries another way (to do a linkTo request)
-     */
-    setItemMoved(entry: ItemEntry, to: EntryParent): void;
-}
+import { ItemEntry } from '../models';
+import { EntryParent, FieldMap, ItemIdConversionMap, ItemType } from '../types';
+import { ChangesDeltaBase } from './ChangesDeltaBase';
+import { ItemEntryService } from './ItemEntryService';
+export declare type InternalCreateDelta<ItemTypeType extends ItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    fields: FieldMap<ItemTypeType>;
+};
+/**
+ * @description
+ * ChangesDelta used internally by the core
+ *
+ * ----------
+ *
+ * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the InternalChangesDelta
+ * assumes 'created' entries are already existing, so it has a different format.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent} and {@link TransactionCache.applyChangesFromChild applyChangesFromChild}
+ */
+export declare class InternalChangesDelta extends ChangesDeltaBase {
+    created: {
+        [itemEntryId: string]: InternalCreateDelta;
+    };
+    moved: {
+        [itemEntryId: number]: {
+            entry: ItemEntry;
+            to: EntryParent;
+        };
+    };
+    itemIdConversionMap: ItemIdConversionMap;
+    constructor(itemEntryService: ItemEntryService);
+    setItemCreated<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): void;
+    /**
+     * @remark
+     * Parent fields are non-writable so we need to keep track of moved entries another way (to do a linkTo request)
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent): void;
+}

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

@@ -1,29 +1,29 @@
-import { QueryMatcherFactory } from '../factories';
-import { ItemEntry } from '../models';
-import { CollectionQuery, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
-import { AbstractCache } from './cache/AbstractCache';
-export declare class ItemCache {
-    private queryMatcherFactory;
-    private transaction;
-    private entries;
-    entriesByEntryId: {
-        [itemEntryId: number]: ItemEntry;
-    };
-    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
-    getByEntryId(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    some(callback: (itemEntry: ItemEntry<ItemType>) => boolean): boolean;
-    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
-    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): ItemEntry<ItemTypeType>[];
-    getLocalByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): ItemEntry<ItemTypeType>[];
-    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
-    batchGetLocalByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentIds: ItemId[], itemType: ItemTypeType, additionalQuery: any): ItemEntryParentIdMap<ItemTypeType>;
-    forEach(callback: (itemEntry: ItemEntry<ItemType>) => void): void;
-    toArray(): ItemEntry<string>[];
-    add<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>): ItemEntry<ItemTypeType>;
-    get<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId): undefined | ItemEntry<ItemTypeType>;
-    contains(itemType: ItemType, itemId: string | ItemId): boolean;
-    updateItemId<T extends ItemEntry<any>>(itemEntry: T, oldItemId: string | ItemId): T;
-    clear(itemEntry?: ItemEntry<any>): boolean;
-    clearByItemId(itemType: ItemType, itemId: ItemId): boolean;
-    matchQuery(itemEntry: ItemEntry<any>, query: CollectionQuery): boolean;
-}
+import { QueryMatcherFactory } from '../factories';
+import { ItemEntry } from '../models';
+import { CollectionQuery, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
+import { AbstractCache } from './cache/AbstractCache';
+export declare class ItemCache {
+    private queryMatcherFactory;
+    private transaction;
+    private entries;
+    entriesByEntryId: {
+        [itemEntryId: number]: ItemEntry;
+    };
+    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
+    getByEntryId(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    some(callback: (itemEntry: ItemEntry<ItemType>) => boolean): boolean;
+    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
+    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): ItemEntry<ItemTypeType>[];
+    getLocalByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): ItemEntry<ItemTypeType>[];
+    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
+    batchGetLocalByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentIds: ItemId[], itemType: ItemTypeType, additionalQuery: any): ItemEntryParentIdMap<ItemTypeType>;
+    forEach(callback: (itemEntry: ItemEntry<ItemType>) => void): void;
+    toArray(): ItemEntry<string>[];
+    add<ItemTypeType extends ItemType>(itemEntry: ItemEntry<ItemTypeType>): ItemEntry<ItemTypeType>;
+    get<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: string | ItemId): undefined | ItemEntry<ItemTypeType>;
+    contains(itemType: ItemType, itemId: string | ItemId): boolean;
+    updateItemId<T extends ItemEntry<any>>(itemEntry: T, oldItemId: string | ItemId): T;
+    clear(itemEntry?: ItemEntry<any>): boolean;
+    clearByItemId(itemType: ItemType, itemId: ItemId): boolean;
+    matchQuery(itemEntry: ItemEntry<any>, query: CollectionQuery): boolean;
+}

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

@@ -1,41 +1,41 @@
-import { KeyService } from '../classes';
-import { AuthInterface } from '../interfaces';
-import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
-import { ItemEntry, ItemEntryOptions } from '../models';
-import { ApiResponse, EntryParent, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
-export declare class ItemEntryService {
-    private authInterface;
-    private keyService;
-    private linkTreeService;
-    constructor(authInterface: AuthInterface, keyService: KeyService, linkTreeService: LinkTreeServiceInterface);
-    matchParent(oldParent: EntryParentNull, newParent: EntryParentNull): boolean;
-    /**
-     * @description
-     * Gets the fields required to set the parent
-     *
-     * @remark
-     * Opposite of {@link ItemEntryService.getParentByFields ItemEntryService.getParentByFields}
-     */
-    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
-    /**
-     * @description
-     * Gets an {@link EntryParent EntryParent} object from the fields
-     *
-     * @remark
-     * Opposite of {@link ItemEntryService.getLinkFieldsByParent ItemEntryService.getLinkFieldsByParent}
-     */
-    getParentByFields<ItemTypeType extends ItemType>(parentType: ItemType, itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): Partial<FieldMap<ItemTypeType>>;
-    getDisplayName<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): string;
-    processOptions(options: ItemOptionsInterface): ItemEntryOptions;
-    createUnfoundRemoteItemError(): ItemError;
-    createUnfoundLocalItemError(itemType: ItemType): ItemError;
-    createExistingLocalItemError(itemType: ItemType): ItemError;
-    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
-    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
-    expandConversionMap(itemEntry: ItemEntry<any>, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
-    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
-    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
-    getFullName(firstName?: string, infix?: string, lastName?: string): string;
-    getTitleField(itemType: ItemType): string;
-    getLocalDefaultValues(): FieldMap;
-}
+import { KeyService } from '../classes';
+import { AuthInterface } from '../interfaces';
+import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
+import { ItemEntry, ItemEntryOptions } from '../models';
+import { ApiResponse, EntryParent, EntryParentNull, FieldMap, ItemError, ItemId, ItemIdConversionMap, ItemOptionsInterface, ItemType } from '../types';
+export declare class ItemEntryService {
+    private authInterface;
+    private keyService;
+    private linkTreeService;
+    constructor(authInterface: AuthInterface, keyService: KeyService, linkTreeService: LinkTreeServiceInterface);
+    matchParent(oldParent: EntryParentNull, newParent: EntryParentNull): boolean;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     *
+     * @remark
+     * Opposite of {@link ItemEntryService.getParentByFields ItemEntryService.getParentByFields}
+     */
+    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    /**
+     * @description
+     * Gets an {@link EntryParent EntryParent} object from the fields
+     *
+     * @remark
+     * Opposite of {@link ItemEntryService.getLinkFieldsByParent ItemEntryService.getLinkFieldsByParent}
+     */
+    getParentByFields<ItemTypeType extends ItemType>(parentType: ItemType, itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): Partial<FieldMap<ItemTypeType>>;
+    getDisplayName<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): string;
+    processOptions(options: ItemOptionsInterface): ItemEntryOptions;
+    createUnfoundRemoteItemError(): ItemError;
+    createUnfoundLocalItemError(itemType: ItemType): ItemError;
+    createExistingLocalItemError(itemType: ItemType): ItemError;
+    createLocalConversionMap(itemType: ItemType, itemId: ItemId, doExtend: boolean | undefined, apiResponse: ApiResponse): ItemIdConversionMap;
+    expandLocalConversionMap(parentType: ItemType, parentId: ItemId, apiResponse: ApiResponse, conversionMap: ItemIdConversionMap): void;
+    expandConversionMap(itemEntry: ItemEntry<any>, conversionMap: ItemIdConversionMap, newItemId?: ItemId): ItemId;
+    batchExpandConversionMap(itemEntries: Array<ItemEntry<any>>, conversionMap: ItemIdConversionMap): ItemIdConversionMap;
+    getConversionValue(itemType: ItemType, itemId: ItemId, map: ItemIdConversionMap): ItemId | undefined;
+    getFullName(firstName?: string, infix?: string, lastName?: string): string;
+    getTitleField(itemType: ItemType): string;
+    getLocalDefaultValues(): FieldMap;
+}

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

@@ -1,16 +1,16 @@
-import { ItemId, StateKey } from '../types';
-export declare class KeyService {
-    separator: string;
-    constructor();
-    getSingleKey(itemType: string, itemId: number | string): string;
-    getCssKey(...args: any[]): string;
-    parseStateKey(stateKey: string): StateKey | null;
-    getDuplicateStateKey(itemId: string | number): string;
-    getNewStateKey(templateType: string): string;
-    getLocalId(): ItemId;
-    getLocalDuplicateId(): ItemId;
-    getRandomString(): string;
-    isLocalId(itemId: ItemId | string): boolean;
-    isNewId(itemId: ItemId | string): boolean;
-    isDuplicateId(itemId: ItemId | string): boolean;
-}
+import { ItemId, StateKey } from '../types';
+export declare class KeyService {
+    separator: string;
+    constructor();
+    getSingleKey(itemType: string, itemId: number | string): string;
+    getCssKey(...args: any[]): string;
+    parseStateKey(stateKey: string): StateKey | null;
+    getDuplicateStateKey(itemId: string | number): string;
+    getNewStateKey(templateType: string): string;
+    getLocalId(): ItemId;
+    getLocalDuplicateId(): ItemId;
+    getRandomString(): string;
+    isLocalId(itemId: ItemId | string): boolean;
+    isNewId(itemId: ItemId | string): boolean;
+    isDuplicateId(itemId: ItemId | string): boolean;
+}

package/dist/src/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;
-    fetchCachedLock(itemEntry: ItemEntry<any>): PromiseInterface<undefined | LockToken>;
-    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<string>;
-    requestLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
-    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
-    clearLock(itemEntry: ItemEntry<any>): boolean;
-    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;
+    fetchCachedLock(itemEntry: ItemEntry<any>): PromiseInterface<undefined | LockToken>;
+    fetchLock(itemEntry: ItemEntry<any>): PromiseInterface<string>;
+    requestLock(itemEntry: ItemEntry<any>): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry<any>): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry<any>): boolean;
+    private getValue;
+    private setValue;
+}

package/dist/src/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/src/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/src/classes/QueryMatcher.d.ts

@@ -1,14 +1,14 @@
-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;
-    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;
+    matchQuery(query: ApiQuery): boolean | 'maybe';
+    private matchLinkedToQuery;
+    private matchComplexQuery;
+    private matchSimpleQuery;
+}

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

@@ -1,25 +1,25 @@
-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]> {
-    private parameters;
-    constructor(query: ApiQuery, parameters: object);
-    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]> {
+    private parameters;
+    constructor(query: ApiQuery, parameters: object);
+    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/src/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): ReturnType;
-    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean): ReturnType;
-    protected abstract parseSearchQuery(value: any, not: boolean): ReturnType;
-    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean): ReturnType;
-    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not?: boolean): ReturnType;
-    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean): ReturnType;
-    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean): 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): ReturnType;
+    protected abstract parseSubFieldQuery(key: string, itemType: ItemType, field: string, query: ApiQuery, not: boolean): ReturnType;
+    protected abstract parseSearchQuery(value: any, not: boolean): ReturnType;
+    protected abstract parseCustomQuery(custom: string, parameters: any, not: boolean): ReturnType;
+    protected abstract parseSimpleQuery(key: string, value: any, comparator: COMPARATORS_TYPE, not?: boolean): ReturnType;
+    protected abstract parseLinkedToQuery(linkedTo: any, query: ApiQuery, reverse: boolean, not: boolean): ReturnType;
+    protected abstract parseComplexQuery(conditions: any[], operator: OPERATORS_TYPE, not: boolean): ReturnType;
+}

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

@@ -1,14 +1,14 @@
-import { ApiQuery, EntryParentNull, ItemId } from '../types';
-import { COMPARATORS } from './QueryParserBase';
-export declare class QueryService {
-    constructor();
-    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 } from '../types';
+import { COMPARATORS } from './QueryParserBase';
+export declare class QueryService {
+    constructor();
+    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;
+    };
+}