@rentman/rm-core 7.1.1 → 8.0.0

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

@@ -1,6 +1,7 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { QueryMatcherFactory } from '../factories';
 import { ItemEntry } from '../models';
-import { CollectionQuery, ItemEntryParentIdMap, ItemId, ItemType } from '../types';
+import { CollectionQuery, ItemEntryParentIdMap } from '../types';
 import { AbstractCache } from './cache/AbstractCache';
 export declare class ItemCache {
     private queryMatcherFactory;
@@ -11,19 +12,19 @@ export declare class ItemCache {
     };
     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['object']): ItemEntry<ItemTypeType>[];
-    getLocalByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): 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: CollectionQuery['object']): ItemEntryParentIdMap<ItemTypeType>;
+    some(callback: (itemEntry: ItemEntry) => boolean): boolean;
+    getByItemType<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType): Array<ItemEntry<ItemTypeType>>;
+    getByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): Array<ItemEntry<ItemTypeType>>;
+    getLocalByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery['object']): Array<ItemEntry<ItemTypeType>>;
+    getByParent<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentId: ItemId, itemType: ItemTypeType): ItemEntry<ItemTypeType>[];
+    batchGetLocalByParent<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIds: ItemId[], itemType: ItemTypeType, additionalQuery: CollectionQuery['object']): ItemEntryParentIdMap<ItemTypeType>;
     forEach(callback: (itemEntry: ItemEntry) => 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;
+    toArray(): ItemEntry<any>[];
+    add<ItemTypeType extends ApiEnumItemType>(itemEntry: ItemEntry<ItemTypeType>): ItemEntry<ItemTypeType>;
+    get<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: string | ItemId): undefined | ItemEntry<ItemTypeType>;
+    contains(itemType: ApiEnumItemType, 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;
+    clearByItemId(itemType: ApiEnumItemType, itemId: ItemId): boolean;
     matchQuery(itemEntry: ItemEntry<any>, query: CollectionQuery['object']): boolean;
 }

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
 import { ColumnSetFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
-import { ColumnIdTypeMap, EntryParentNull, FieldMap, FilterItemEntryCallback, ItemId, ItemIdConversionMap, ItemType, ModifyFieldsCallback, PromiseInterface } from '../types';
+import { EntryParentNull, FieldMap, FilterItemEntryCallback, ItemIdConversionMap, ModifyFieldsCallback, PromiseInterface } from '../types';
 import { ChangesDelta } from './ChangesDelta';
 import { ConversionMapService } from './ConversionMapService';
 import { KeyService } from './KeyService';
@@ -18,7 +19,7 @@ export declare class ItemCreateService {
      * @description
      * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
      */
-    createItemsFromValues<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<FieldMap<ItemTypeType, Fields>>, parent?: EntryParentNull): PromiseInterface<void>;
-    processTemplate<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, Fields>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
-    processTemplateLinkItems<ParentItemType extends ItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    createItemsFromValues<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Array<Partial<FieldMap<ItemTypeType, ColumnIds>>>, parent?: EntryParentNull): PromiseInterface<void>;
+    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+    processTemplateLinkItems<ParentItemType extends ApiEnumItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
 }

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { AuthInterface } from '../interfaces';
 import { LinkTreeServiceInterface } from '../interfaces/LinkTreeServiceInterface';
 import { ItemEntry, ItemEntryOptions } from '../models';
-import { EntryParent, EntryParentNull, FieldMap, ItemError, ItemOptionsInterface, ItemType } from '../types';
+import { EntryParent, EntryParentNull, FieldMap, ItemError, ItemOptionsInterface } from '../types';
 export declare class ItemEntryService {
     private authInterface;
     private linkTreeService;
@@ -14,7 +15,7 @@ export declare class ItemEntryService {
      * @remark
      * Opposite of {@link ItemEntryService.getParentByFields ItemEntryService.getParentByFields}
      */
-    getLinkFieldsByParent<ItemTypeType extends ItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    getLinkFieldsByParent<ParentItemType extends ApiEnumItemType, ItemTypeType extends ApiEnumItemType>(parent: EntryParent<ParentItemType>, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
     /**
      * @description
      * Gets an {@link EntryParent EntryParent} object from the fields
@@ -22,13 +23,13 @@ export declare class ItemEntryService {
      * @remark
      * Opposite of {@link ItemEntryService.getLinkFieldsByParent ItemEntryService.getLinkFieldsByParent}
      */
-    getParentByFields<ItemTypeType extends ItemType>(parentType: ItemType, itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): Partial<FieldMap<ItemTypeType>>;
+    getParentByFields<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, itemEntry: ItemEntry<ItemTypeType>, fields: FieldMap<ItemTypeType>): EntryParent;
     getDisplayName<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): string | undefined;
     processOptions(options: ItemOptionsInterface): ItemEntryOptions;
     createUnfoundRemoteItemError(): ItemError;
-    createUnfoundLocalItemError(itemType: ItemType): ItemError;
-    createExistingLocalItemError(itemType: ItemType): ItemError;
+    createUnfoundLocalItemError(itemType: ApiEnumItemType): ItemError;
+    createExistingLocalItemError(itemType: ApiEnumItemType): ItemError;
     getFullName(firstName: string, infix: string, lastName: string): string | undefined;
-    getTitleField(itemType: ItemType): string;
-    getLocalDefaultValues(): FieldMap;
+    getTitleField(itemType: ApiEnumItemType): string;
+    getLocalDefaultValues<ItemTypeType extends ApiEnumItemType>(): FieldMap<ItemTypeType, ['permissions', 'creator', 'created']>;
 }

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

@@ -1,17 +1,18 @@
-import { ItemId, StateKey } from '../types';
+import { ItemId } from '@rentman/backend-types';
+import { StateKey } from '../types';
 export declare class KeyService {
     private separator;
     private idCounter;
     constructor();
-    getSingleKey(itemType: string, itemId: number | string): string;
+    getSingleKey(itemType: string, itemId: ItemId | string): string;
     getCssKey(...args: any[]): string;
     parseStateKey(stateKey: string): StateKey | null;
-    getDuplicateStateKey(itemId: string | number): string;
+    getDuplicateStateKey(itemId: string | ItemId): 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;
+    isLocalId(itemId: any): boolean;
+    isNewId(itemId: any): boolean;
+    isDuplicateId(itemId: any): boolean;
 }

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

@@ -1,15 +1,13 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 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;
-} | {
+import { FieldMap, PromiseInterface } from '../types';
+declare type LockTokenError = {
     isForeign: true;
     message: string;
 };
+export declare type LockToken = FieldMap<ApiEnumItemType.Locktoken, ['token', 'id']> | LockTokenError;
 export declare class LockService {
     private apiRequestService;
     private errorHandler;
@@ -20,13 +18,15 @@ export declare class LockService {
     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;
+    isLocked(itemEntry: ItemEntry): boolean;
+    getMessage(itemEntry: ItemEntry): undefined | string;
+    fetchLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry): boolean;
     private requestLock;
     private fetchCachedLock;
     private getValue;
     private setValue;
+    isRemoteLock(token: LockToken): token is LockTokenError;
 }
+export {};

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

@@ -1,7 +1,8 @@
-import { ApiRequestItemMap, ItemId, ItemType } from '../types';
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestItemMap } from '../types';
 import { TransactionCache } from './cache/transaction/TransactionCache';
 export declare type ModuleChangesCompilationResult = {
-    itemType: ItemType;
+    itemType: ApiEnumItemType;
     itemId: ItemId;
     items: ApiRequestItemMap;
 };

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

@@ -1,20 +1,20 @@
-import { ApiQuery, ApiRequestColumn, ItemType } from '../types';
+import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ApiRequestColumn } from '../types';
 import { ColumnUtil } from './ColumnUtil';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+import { QueryParserBase } from './QueryParserBase';
 export declare class QueryColumnExtractor extends QueryParserBase<ApiRequestColumn[]> {
     private columnUtil;
     private itemType;
-    constructor(columnUtil: ColumnUtil, itemType: ItemType, query: ApiQuery);
+    constructor(columnUtil: ColumnUtil, itemType: ApiEnumItemType, query: ApiQuery);
     protected parseEmptyQuery(): never[];
-    protected parseSubQuery(key: string, subQuery: object, _not?: boolean): {
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query']): {
         [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;
+    protected parseSubFieldQuery(): never[];
+    protected parseSearchQuery(): never[];
+    protected parseCustomQuery(): never[];
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key']): T["key"][];
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse']): ApiRequestColumn[];
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ApiRequestColumn[];
     private parseConditions;
 }

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

@@ -1,17 +1,17 @@
-import { ApiQuery, ItemType } from '../types';
+import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQueryConditionComparator, ApiQueryWithConditions } from '../types';
 import { KeyService } from './KeyService';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+import { 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;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): boolean;
+    protected parseSubFieldQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], _itemType: T['itemType'], field: T['field'], query: T['query']): boolean;
+    protected parseSearchQuery(): boolean;
+    protected parseCustomQuery(): boolean;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value']): boolean;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query: T['query']): boolean;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): 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';
+import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryWithConditions } from '../types';
+import { QueryParserBase } from './QueryParserBase';
 export declare class QueryLinkedToParser extends QueryParserBase<boolean> {
     private callback;
-    constructor(callback: (linkedTo: ItemType, query: ApiQuery) => boolean, query: ApiQuery);
+    constructor(callback: <ItemTypeType extends ApiEnumItemType>(linkedTo: ItemTypeType, query: ApiQuery<ItemTypeType>) => 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;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): boolean;
+    protected parseSubFieldQuery(): boolean;
+    protected parseSearchQuery(): boolean;
+    protected parseCustomQuery(): boolean;
+    protected parseSimpleQuery(): boolean;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], _reverse: T['reverse'], not?: T['not']): boolean;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): boolean;
     private parseConditions;
 }

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

@@ -1,6 +1,6 @@
-import { ApiQuery, ItemType } from '../types';
-import { COMPARATORS_TYPE } from './QueryParser';
-import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+import { ApiQueryConditionLinkedTo } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryWithConditions } from '../types';
+import { QueryParserBase } from './QueryParserBase';
 /**
  * @description
  * Returns whether or not a query can be parsed by the {@link QueryMatcher QueryMatcher}
@@ -8,12 +8,12 @@ import { OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
 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;
+    protected parseSubQuery(): boolean;
+    protected parseSubFieldQuery(): boolean;
+    protected parseSearchQuery(): boolean;
+    protected parseCustomQuery(): boolean;
+    protected parseSimpleQuery(): boolean;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse'], _not: T['not']): boolean;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): boolean;
     private parseConditions;
 }

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

@@ -1,11 +1,12 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ApiFormatter } from '../classes';
-import { ApiQuery, EntryParentNull, FieldMap, ItemType } from '../types';
+import { ApiQuery, EntryParentNull, FieldMap } from '../types';
 export declare class QueryMatcher {
     private apiFormatter;
-    itemType: ItemType;
+    itemType: ApiEnumItemType;
     fields: FieldMap;
     parent: EntryParentNull;
-    constructor(apiFormatter: ApiFormatter, itemType: ItemType, fields: FieldMap, parent?: EntryParentNull);
+    constructor(apiFormatter: ApiFormatter, itemType: ApiEnumItemType, fields: FieldMap, parent?: EntryParentNull);
     private compareValues;
     /**
      * @remark

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

@@ -1,24 +1,26 @@
-import { ApiQuery } from '../types';
-import { COMPARATORS, OPERATORS_TYPE, QueryParserBase } from './QueryParserBase';
+import { ApiQuery as BackendApiQuery, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions } from '../types';
+import { 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]> {
+declare type ReturnType = [BackendApiQuery, string];
+export declare class QueryParser extends QueryParserBase<ReturnType> {
     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];
+    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>(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/classes/QueryParserBase.d.ts

@@ -1,29 +1,20 @@
-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;
+import { ApiQueryConditionCustom, ApiQueryConditionLinkedTo, ApiQueryConditionSearch, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions } from '../types';
 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;
+    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/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';
+import { ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ItemIdConversionMap } from '../types';
+import { 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;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): void;
+    protected parseSubFieldQuery(): void;
+    protected parseSearchQuery(): void;
+    protected parseCustomQuery(): void;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(_key: T['key'], value: T['value'], _comparator: T['comparator'], _not: T['not'], queryPart: T): void;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(_linkedTo: T['linkedTo'], query?: T['query']): void;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): void;
     private parseConditions;
 }

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

@@ -1,18 +1,13 @@
-import { ApiQuery, EntryParentNull, ItemId, ItemType } from '../types';
+import { ApiEnumItemType, ApiQueryConditionIn, ItemId } from '@rentman/backend-types';
+import { ApiQuery, EntryParentNull } 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;
+    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[]): {
-        comparator: COMPARATORS;
-        key: string;
-        value: number[];
-        not: boolean;
-    };
+    createNotIn(idArray: ItemId[]): ApiQueryConditionIn;
 }

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

@@ -1,11 +1,12 @@
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
 import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
 import { PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiQuery, ApiRequestColumns, 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> {
+export declare type RequestBufferResponse<ItemTypeType extends ApiEnumItemType = any> = ApiResponseProcessor<ItemTypeType>;
+export declare class RequestBuffer<ItemTypeType extends ApiEnumItemType = any> {
     private promiseLibrary;
     private apiRequestService;
     private requestColumnExpansionFactory;
@@ -20,7 +21,7 @@ export declare class RequestBuffer<ItemTypeType extends ItemType = any> {
     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>>;
+    addQuery(query: [ApiQuery, string], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     flush(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     getPromise(): PromiseInterface<RequestBufferResponse<ItemTypeType>>;
     private hasMultipleQueries;

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

@@ -1,6 +1,7 @@
+import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
 import { ChangesDeltaFactory, RequestColumnExpansionFactory } from '../factories';
 import { PromiseLibraryInterface } from '../interfaces';
-import { ApiRequestColumns, ItemId, ItemType, PromiseInterface } from '../types';
+import { ApiRequestColumns, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
 import { ServerCache } from './cache/server/ServerCache';
 import { KeyService } from './KeyService';
@@ -16,9 +17,9 @@ export declare class RequestBufferManager {
     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
+    fetchByIds(itemType: ApiEnumItemType, itemIds: ItemId[], requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchById(itemType: ApiEnumItemType, itemId: ItemId, requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    fetchByQuery(itemType: ApiEnumItemType, query: [ApiQuery, string], // queryParser result
     requestColumns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
     private constructBuffer;
     private _constructBuffer;

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

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

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

@@ -1,16 +1,17 @@
+import { ApiEnumItemType } from '@rentman/backend-types';
 import { ApiFormatter, ApiRequestService } from '../classes';
 import { QueryMatcherFactory, RequestColumnExpansionFactory, TransactionCacheFactory } from '../factories';
 import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemType, SocketMessage } from '../types';
+import { SocketMessage } from '../types';
 import { CachedQueryItem } from './cache/CachedQueryHandlerBase';
 import { RequestBufferManager } from './RequestBufferManager';
-export declare type CachedQueryMatchingResult<ItemTypeType extends ItemType> = {
+export declare type CachedQueryMatchingResult<ItemTypeType extends ApiEnumItemType> = {
     fitting: Array<CachedQueryItem<ItemTypeType>>;
     notfitting: Array<CachedQueryItem<ItemTypeType>>;
     maybe: Array<CachedQueryItem<ItemTypeType>>;
 };
-export declare type CachedQueryMatchingResultItemIdMap<ItemTypeType extends ItemType> = {
+export declare type CachedQueryMatchingResultItemIdMap<ItemTypeType extends ApiEnumItemType> = {
     [itemId: number]: CachedQueryMatchingResult<ItemTypeType>;
 };
 export declare class SocketMessageHandler {

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

@@ -1,7 +1,8 @@
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
 import { RequestColumnExpansionFactory, TemplateFactory } from '../factories';
 import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
 import { Template } from '../models';
-import { ColumnIdTypeMap, EntryParentNull, ItemId, ItemType, PromiseInterface } from '../types';
+import { EntryParentNull, PromiseInterface } from '../types';
 import { ApiRequestService } from './ApiRequestService';
 import { ColumnHandler } from './ColumnHandler';
 import { ColumnUtil } from './ColumnUtil';
@@ -22,7 +23,7 @@ export declare class TemplateCache {
      * @description
      * Fetches a {@link Template template}, {@link TransactionItemHandler.createItems TransactionItemHandler.createItems} is a convenience function for this
      *
-     * @param itemType The {@link ItemType ItemType} of the template item
+     * @param itemType The {@link ApiEnumItemType ItemType} of the template item
      * @param itemId Used for caching, multiple concurrent template calls for the same itemId will return the same template
      * @param templateOptions
      * @param templateColumns Additional columns to be fetched, will be stored in the template - warning - the Template won't have values for those columns
@@ -60,7 +61,7 @@ export declare class TemplateCache {
      *          );
      *  ```
      */
-    fetchTemplate<ItemTypeType extends ItemType, Fields extends ColumnIdTypeMap>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ItemType): PromiseInterface<Template<ItemTypeType, Fields>>;
+    fetchTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends Array<keyof ApiFields[ItemTypeType]> = Array<keyof ApiFields[ItemTypeType]>>(itemType: ItemTypeType, itemId?: ItemId, templateOptions?: any, templateColumns?: any, entryParentOrParentItemType?: EntryParentNull | ApiEnumItemType): PromiseInterface<Template<ItemTypeType, ColumnIds>>;
     private fetchTemplateById;
     private constructTemplateBuffer;
 }

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

@@ -28,4 +28,4 @@ export declare function isElement(node: any): boolean;
 export declare function isWindow(obj: any): boolean;
 export declare function isDefined(value: any): boolean;
 export declare function equals(o1: any, o2: any): boolean;
-export declare function copy(source: any, destination?: any, maxDepth?: any): any;
+export declare function copy(source: object, destination?: object, maxDepth?: any): any;