@rentman/rm-core 11.0.2 → 11.0.4

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

@@ -1,18 +1,18 @@
-import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ChangesDelta, ColumnSetFactory, ConversionMapService, EntryParentNull, ErrorHandlerInterface, FieldMap, FilterItemEntryCallback, ItemIdConversionMap, KeyService, ModifyFieldsCallback, PromiseInterface, PromiseLibraryInterface, Template, TemplateCache } from '../internal';
-export declare class ItemCreateService {
-    private columnSetFactory;
-    private conversionMapService;
-    private errorHandler;
-    private keyService;
-    private promiseService;
-    private templateCache;
-    constructor(columnSetFactory: ColumnSetFactory, conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, templateCache: TemplateCache);
-    /**
-     * @description
-     * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
-     */
-    createItemsFromValues<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[], parent?: EntryParentNull): PromiseInterface<void>;
-    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback, isRoot?: boolean): void;
-    processTemplateLinkItems<ParentItemType extends ApiEnumItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
-}
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
+import { ChangesDelta, ColumnSetFactory, ConversionMapService, EntryParentNull, ErrorHandlerInterface, FieldMap, FilterItemEntryCallback, ItemIdConversionMap, KeyService, ModifyFieldsCallback, PromiseInterface, PromiseLibraryInterface, Template, TemplateCache } from '../internal';
+export declare class ItemCreateService {
+    private columnSetFactory;
+    private conversionMapService;
+    private errorHandler;
+    private keyService;
+    private promiseService;
+    private templateCache;
+    constructor(columnSetFactory: ColumnSetFactory, conversionMapService: ConversionMapService, errorHandler: ErrorHandlerInterface, keyService: KeyService, promiseService: PromiseLibraryInterface, templateCache: TemplateCache);
+    /**
+     * @description
+     * Fetches a new {@link Template template} and sets the items created on the passed {@link ChangesDelta}
+     */
+    createItemsFromValues<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[], parent?: EntryParentNull): PromiseInterface<void>;
+    processTemplate<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(changesDelta: ChangesDelta, itemType: ItemTypeType, itemId: ItemId, parent: EntryParentNull, template: Template<ItemTypeType, ColumnIds>, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback, isRoot?: boolean): void;
+    processTemplateLinkItems<ParentItemType extends ApiEnumItemType>(changesDelta: ChangesDelta, parentType: ParentItemType, localParentId: ItemId, template: Template<ParentItemType>, itemIdConversion: ItemIdConversionMap, filterItemEntryCallback?: FilterItemEntryCallback, modifyFieldsCallback?: ModifyFieldsCallback): void;
+}

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

@@ -1,32 +1,32 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AuthInterface, EntryParent, EntryParentNull, FieldMap, ItemEntry, ItemEntryOptions, ItemError, ItemOptionsInterface, LinkTreeServiceInterface } from '../internal';
-export declare class ItemEntryService {
-    private authInterface;
-    private linkTreeService;
-    constructor(authInterface: AuthInterface, 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<ParentItemType extends ApiEnumItemType, ItemTypeType extends ApiEnumItemType>(parent: EntryParent<ParentItemType>, 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 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: ApiEnumItemType): ItemError;
-    createExistingLocalItemError(itemType: ApiEnumItemType): ItemError;
-    getFullName(firstName: string, infix: string, lastName: string): string | undefined;
-    getTitleField(itemType: ApiEnumItemType): string;
-    getLocalDefaultValues<ItemTypeType extends ApiEnumItemType>(): FieldMap<ItemTypeType, ['permissions', 'creator', 'created']>;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AuthInterface, EntryParent, EntryParentNull, FieldMap, ItemEntry, ItemEntryOptions, ItemError, ItemOptionsInterface, LinkTreeServiceInterface } from '../internal';
+export declare class ItemEntryService {
+    private authInterface;
+    private linkTreeService;
+    constructor(authInterface: AuthInterface, 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<ParentItemType extends ApiEnumItemType, ItemTypeType extends ApiEnumItemType>(parent: EntryParent<ParentItemType>, 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 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: ApiEnumItemType): ItemError;
+    createExistingLocalItemError(itemType: ApiEnumItemType): ItemError;
+    getFullName(firstName: string, infix: string, lastName: string): string | undefined;
+    getTitleField(itemType: ApiEnumItemType): string;
+    getLocalDefaultValues<ItemTypeType extends ApiEnumItemType>(): FieldMap<ItemTypeType, ['permissions', 'creator', 'created']>;
+}

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

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

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

@@ -1,28 +1,28 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiRequestService, ErrorHandlerInterface, FieldMap, ItemEntry, KeyService, PromiseInterface, PromiseLibraryInterface } from '../internal';
-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;
-    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): boolean;
-    getMessage(itemEntry: ItemEntry): undefined | string;
-    fetchLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
-    deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
-    clearLock(itemEntry: ItemEntry): boolean;
-    isRemoteLock(token: LockToken): token is LockTokenError;
-    private requestLock;
-    private getValue;
-    private setValue;
-}
-export {};
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestService, ErrorHandlerInterface, FieldMap, ItemEntry, KeyService, PromiseInterface, PromiseLibraryInterface } from '../internal';
+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;
+    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): boolean;
+    getMessage(itemEntry: ItemEntry): undefined | string;
+    fetchLock(itemEntry: ItemEntry): PromiseInterface<LockToken>;
+    deleteLock(itemEntry: ItemEntry): PromiseInterface<void>;
+    clearLock(itemEntry: ItemEntry): boolean;
+    isRemoteLock(token: LockToken): token is LockTokenError;
+    private requestLock;
+    private getValue;
+    private setValue;
+}
+export {};

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

@@ -1,18 +1,18 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ApiRequestItemMap, TransactionCache } from '../internal';
-export declare type ModuleChangesCompilationResult = {
-    itemType: ApiEnumItemType;
-    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 { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestItemMap, TransactionCache } from '../internal';
+export declare type ModuleChangesCompilationResult = {
+    itemType: ApiEnumItemType;
+    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/src/classes/ParentChangesDelta.d.ts

@@ -1,41 +1,41 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ApiFormatter, ChangesDeltaBase, ChangesDeltaItemDeleteDelta, EntryParent, FieldMap, InternalCreateDelta, ItemEntry, ItemEntryService, ItemIdConversionMap } from '../internal';
-export declare type ParentChangesDeltaItemDeleteDelta = ItemEntry;
-/**
- * @description
- * ChangesDelta used internally by the core
- *
- * ----------
- *
- * The difference between {@link ParentChangesDelta ParentChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ParentChangesDelta
- * assumes 'created' entries are already existing, and deletedEntries don't have changes (since you cannot undo an action that happened on a parent on a child transaction)
- *
- * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent}
- */
-export declare class ParentChangesDelta extends ChangesDeltaBase {
-    created: {
-        [itemEntryId: string]: InternalCreateDelta;
-    };
-    deleted: {
-        [itemType: string]: {
-            [entryId: string]: ParentChangesDeltaItemDeleteDelta;
-        };
-    };
-    moved: {
-        [itemEntryId: number]: {
-            entry: ItemEntry;
-            to: EntryParent;
-        };
-    };
-    itemIdConversionMap: ItemIdConversionMap;
-    constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
-    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
-    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
-    setItemCreated<ItemTypeType extends ApiEnumItemType>(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;
-    isEmpty(): boolean;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { ApiFormatter, ChangesDeltaBase, ChangesDeltaItemDeleteDelta, EntryParent, FieldMap, InternalCreateDelta, ItemEntry, ItemEntryService, ItemIdConversionMap } from '../internal';
+export declare type ParentChangesDeltaItemDeleteDelta = ItemEntry;
+/**
+ * @description
+ * ChangesDelta used internally by the core
+ *
+ * ----------
+ *
+ * The difference between {@link ParentChangesDelta ParentChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ParentChangesDelta
+ * assumes 'created' entries are already existing, and deletedEntries don't have changes (since you cannot undo an action that happened on a parent on a child transaction)
+ *
+ * Use this when calling {@link TransactionCache.applyChangesFromParent applyChangesFromParent}
+ */
+export declare class ParentChangesDelta extends ChangesDeltaBase {
+    created: {
+        [itemEntryId: string]: InternalCreateDelta;
+    };
+    deleted: {
+        [itemType: string]: {
+            [entryId: string]: ParentChangesDeltaItemDeleteDelta;
+        };
+    };
+    moved: {
+        [itemEntryId: number]: {
+            entry: ItemEntry;
+            to: EntryParent;
+        };
+    };
+    itemIdConversionMap: ItemIdConversionMap;
+    constructor(itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
+    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
+    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
+    setItemCreated<ItemTypeType extends ApiEnumItemType>(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;
+    isEmpty(): boolean;
+}

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

@@ -1,18 +1,18 @@
-import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ApiRequestColumn, ColumnUtil, QueryParserBase } from '../internal';
-declare type ReturnType = ApiRequestColumn[];
-export declare class QueryColumnExtractor extends QueryParserBase<ReturnType> {
-    private columnUtil;
-    private itemType;
-    constructor(columnUtil: ColumnUtil, itemType: ApiEnumItemType, query: ApiQuery);
-    protected parseEmptyQuery(): ReturnType;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query']): ReturnType;
-    protected parseSubFieldQuery(): ReturnType;
-    protected parseSearchQuery(): ReturnType;
-    protected parseCustomQuery(): ReturnType;
-    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key']): ReturnType;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse']): ReturnType;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
-    private parseConditions;
-}
-export {};
+import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryConditionComparator, ApiQueryWithConditions, ApiRequestColumn, ColumnUtil, QueryParserBase } from '../internal';
+declare type ReturnType = ApiRequestColumn[];
+export declare class QueryColumnExtractor extends QueryParserBase<ReturnType> {
+    private columnUtil;
+    private itemType;
+    constructor(columnUtil: ColumnUtil, itemType: ApiEnumItemType, query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery<T extends ApiQueryConditionComparator>(key: T['key']): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], _query: T['query'], reverse: T['reverse']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
+    private parseConditions;
+}
+export {};

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

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

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

@@ -1,17 +1,17 @@
-import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
-import { ApiQuery, ApiQueryWithConditions, QueryParserBase } from '../internal';
-declare type ReturnType = boolean;
-export declare class QueryLinkedToParser extends QueryParserBase<ReturnType> {
-    private callback;
-    constructor(callback: <ItemTypeType extends ApiEnumItemType>(linkedTo: ItemTypeType, query: ApiQuery<ItemTypeType>) => boolean, query: ApiQuery);
-    protected parseEmptyQuery(): ReturnType;
-    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
-    protected parseSubFieldQuery(): ReturnType;
-    protected parseSearchQuery(): ReturnType;
-    protected parseCustomQuery(): ReturnType;
-    protected parseSimpleQuery(): ReturnType;
-    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], _reverse: T['reverse'], not?: T['not']): ReturnType;
-    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
-    private parseConditions;
-}
-export {};
+import { ApiEnumItemType, ApiQueryConditionLinkedTo, ApiQueryConditionSubQuery } from '@rentman/backend-types';
+import { ApiQuery, ApiQueryWithConditions, QueryParserBase } from '../internal';
+declare type ReturnType = boolean;
+export declare class QueryLinkedToParser extends QueryParserBase<ReturnType> {
+    private callback;
+    constructor(callback: <ItemTypeType extends ApiEnumItemType>(linkedTo: ItemTypeType, query: ApiQuery<ItemTypeType>) => boolean, query: ApiQuery);
+    protected parseEmptyQuery(): ReturnType;
+    protected parseSubQuery<T extends ApiQueryConditionSubQuery>(_key: T['key'], subQuery: T['query']): ReturnType;
+    protected parseSubFieldQuery(): ReturnType;
+    protected parseSearchQuery(): ReturnType;
+    protected parseCustomQuery(): ReturnType;
+    protected parseSimpleQuery(): ReturnType;
+    protected parseLinkedToQuery<T extends ApiQueryConditionLinkedTo>(linkedTo: T['linkedTo'], query: T['query'], _reverse: T['reverse'], not?: T['not']): ReturnType;
+    protected parseComplexQuery<T extends ApiQueryWithConditions>(conditions: T['conditions']): ReturnType;
+    private parseConditions;
+}
+export {};

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

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

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

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

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

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

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

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