@rentman/rm-core 9.2.0 → 9.2.2

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

@@ -1,73 +1,73 @@
-import { ApiEnumApiType, ApiEnumItemType, ApiFields, ResponseColumn } from '@rentman/backend-types';
-import moment from 'moment';
-import { ApiEnumApiTypeToTsTypeMap, ColumnInfo, FieldMap, ItemTypeColumnIds } from '../internal';
-declare type GetChangesResult<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> = {
-    oldValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
-    newValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
-    column: ResponseColumn<ItemTypeType, ColumnId>;
-};
-/**
- * @description
- * A service which provides functions to transform data that comes from/goes to the API
- *
- * @warning
- * The code in these functions can be *very hot* on large databases, therefore performance must be kept in mind.
- * This is also the reason why all column types are written out instead of using the enum
- */
-export declare class ApiFormatter {
-    MOMENT_INVALID: string;
-    SERVER_DATETIME_FORMAT: string;
-    SERVER_TIME_FORMAT: string;
-    SERVER_DATE_FORMAT: string;
-    constructor();
-    /**
-     * @description
-     * Returns if a column type is an 'expensive' type, meaning that the action to format the field takes significant CPU time
-     *
-     * ----
-     * @remarks
-     * Currently only used for Moment objects
-     */
-    isExpensiveFormat(columnType: ApiEnumApiType): boolean;
-    /**
-     * @description
-     * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
-     */
-    mergeCopyFields<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, changes: FieldMap<ItemTypeType, ColumnIds>, newInitial: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType, ColumnIds>;
-    formatRequest<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
-        [columnId: string]: any;
-    };
-    formatRequestLocal<ItemTypeType extends ApiEnumItemType>(fields: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
-        [columnId: string]: any;
-    };
-    hasChanges<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[], includeReadOnlyColumns?: boolean, forceCompare?: boolean): boolean;
-    getChanges<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, modified: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): GetChangesResult<ItemTypeType, ColumnIds[number]>[];
-    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: FieldMap<ItemTypeType, ColumnIds>, destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): FieldMap<ItemTypeType, ColumnIds>;
-    shallowCopyFields<ItemTypeType extends ApiEnumItemType>(shallowSource: FieldMap<ItemTypeType>, deepSource: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
-    setDefaultValues<ItemTypeType extends ApiEnumItemType = any>(destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
-    /**
-     * @description
-     * Compares the given fields, returns `true` when the fields are equal
-     */
-    compareFields<ColumnType extends ApiEnumApiType>(columnType: ColumnType, first?: ApiEnumApiTypeToTsTypeMap[ColumnType], second?: ApiEnumApiTypeToTsTypeMap[ColumnType]): boolean;
-    compareFloats(a: number, b: number): boolean;
-    compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
-    compareDurations(first: moment.Duration, second: moment.Duration): boolean;
-    formatResponseValue(columnType: string, value: any): any;
-    formatRequestValue(columnType: string, value: any): any;
-    formatResponseDate(value: null | any): moment.Moment;
-    formatResponseDuration(value: null | number): moment.Duration;
-    formatResponseColor(value: string): string;
-    formatRequestDateTime(value: moment.Moment): string | null;
-    formatRequestDate(value: moment.Moment): string | null;
-    formatRequestDuration(value: moment.Duration): number;
-    formatRequestColor(value: string): string;
-    getDefaultValue(columnType: ApiEnumApiType): any;
-    isDefaultValue(columnType: ApiEnumApiType, value: any): boolean;
-    clone(columnType: string, value: any): any;
-    getCloneFunction(columnType: string): ((duration: moment.Duration) => moment.Duration) | ((date: moment.Moment) => moment.Moment);
-    cloneDuration(duration: moment.Duration): moment.Duration;
-    cloneDate(date: moment.Moment): moment.Moment;
-    identity<T>(input: T): T;
-}
-export {};
+import { ApiEnumApiType, ApiEnumItemType, ApiFields, ResponseColumn } from '@rentman/backend-types';
+import moment from 'moment';
+import { ApiEnumApiTypeToTsTypeMap, ColumnInfo, FieldMap, ItemTypeColumnIds } from '../internal';
+declare type GetChangesResult<ItemTypeType extends ApiEnumItemType = any, ColumnId extends keyof ApiFields[ItemTypeType] = any> = {
+    oldValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
+    newValue: FieldMap<ItemTypeType, [ColumnId]>[ColumnId];
+    column: ResponseColumn<ItemTypeType, ColumnId>;
+};
+/**
+ * @description
+ * A service which provides functions to transform data that comes from/goes to the API
+ *
+ * @warning
+ * The code in these functions can be *very hot* on large databases, therefore performance must be kept in mind.
+ * This is also the reason why all column types are written out instead of using the enum
+ */
+export declare class ApiFormatter {
+    MOMENT_INVALID: string;
+    SERVER_DATETIME_FORMAT: string;
+    SERVER_TIME_FORMAT: string;
+    SERVER_DATE_FORMAT: string;
+    constructor();
+    /**
+     * @description
+     * Returns if a column type is an 'expensive' type, meaning that the action to format the field takes significant CPU time
+     *
+     * ----
+     * @remarks
+     * Currently only used for Moment objects
+     */
+    isExpensiveFormat(columnType: ApiEnumApiType): boolean;
+    /**
+     * @description
+     * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
+     */
+    mergeCopyFields<ItemTypeType extends ApiEnumItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, changes: FieldMap<ItemTypeType, ColumnIds>, newInitial: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType, ColumnIds>;
+    formatRequest<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
+        [columnId: string]: any;
+    };
+    formatRequestLocal<ItemTypeType extends ApiEnumItemType>(fields: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): {
+        [columnId: string]: any;
+    };
+    hasChanges<ItemTypeType extends ApiEnumItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[], includeReadOnlyColumns?: boolean, forceCompare?: boolean): boolean;
+    getChanges<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(initial: FieldMap<ItemTypeType, ColumnIds>, modified: FieldMap<ItemTypeType, ColumnIds>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): GetChangesResult<ItemTypeType, ColumnIds[number]>[];
+    copyFields<ItemTypeType extends ApiEnumItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any>(source: FieldMap<ItemTypeType, ColumnIds>, destination: Partial<FieldMap<ItemTypeType>>, columns: ColumnInfo<ItemTypeType, ColumnIds[number]>[]): FieldMap<ItemTypeType, ColumnIds>;
+    shallowCopyFields<ItemTypeType extends ApiEnumItemType>(shallowSource: FieldMap<ItemTypeType>, deepSource: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
+    setDefaultValues<ItemTypeType extends ApiEnumItemType = any>(destination: FieldMap<ItemTypeType>, columns: ColumnInfo<ItemTypeType>[]): FieldMap<ItemTypeType>;
+    /**
+     * @description
+     * Compares the given fields, returns `true` when the fields are equal
+     */
+    compareFields<ColumnType extends ApiEnumApiType>(columnType: ColumnType, first?: ApiEnumApiTypeToTsTypeMap[ColumnType], second?: ApiEnumApiTypeToTsTypeMap[ColumnType]): boolean;
+    compareFloats(a: number, b: number): boolean;
+    compareMomentObjects(first: moment.Moment, second: moment.Moment): boolean;
+    compareDurations(first: moment.Duration, second: moment.Duration): boolean;
+    formatResponseValue(columnType: string, value: any): any;
+    formatRequestValue(columnType: string, value: any): any;
+    formatResponseDate(value: null | any): moment.Moment;
+    formatResponseDuration(value: null | number): moment.Duration;
+    formatResponseColor(value: string): string;
+    formatRequestDateTime(value: moment.Moment): string | null;
+    formatRequestDate(value: moment.Moment): string | null;
+    formatRequestDuration(value: moment.Duration): number;
+    formatRequestColor(value: string): string;
+    getDefaultValue(columnType: ApiEnumApiType): any;
+    isDefaultValue(columnType: ApiEnumApiType, value: any): boolean;
+    clone(columnType: string, value: any): any;
+    getCloneFunction(columnType: string): ((duration: moment.Duration) => moment.Duration) | ((date: moment.Moment) => moment.Moment);
+    cloneDuration(duration: moment.Duration): moment.Duration;
+    cloneDate(date: moment.Moment): moment.Moment;
+    identity<T>(input: T): T;
+}
+export {};

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

@@ -1,18 +1,18 @@
-import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
-import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestServiceInterface, ApiResponseProcessor, ApiResponseProcessorFactory, PromiseInterface } from '../internal';
-export declare class ApiRequestService {
-    private externalApiRequestService;
-    private apiResponseProcessorFactory;
-    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
-    template(itemType: ApiEnumItemType, params: any): PromiseInterface<ApiResponseProcessor>;
-    create(itemType: ApiEnumItemType, itemId: ItemId, values: any, parentType?: ApiEnumItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
-    delete(itemType: ApiEnumItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
-    updateItems(itemType: ApiEnumItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
-    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
-    moveItems(parentType: ApiEnumItemType, parentId: ItemId, items: {
-        [itemType: string]: ItemId[];
-    }): PromiseInterface<ApiResponseProcessor>;
-    columns(itemType: ApiEnumItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
-    query<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery<ItemTypeType>, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
-    processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
-}
+import { ApiEnumItemType, ApiQuery, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumnMap, ApiRequestItemMap, ApiRequestLimit, ApiRequestServiceInterface, ApiResponseProcessor, ApiResponseProcessorFactory, PromiseInterface } from '../internal';
+export declare class ApiRequestService {
+    private externalApiRequestService;
+    private apiResponseProcessorFactory;
+    constructor(externalApiRequestService: ApiRequestServiceInterface, apiResponseProcessorFactory: ApiResponseProcessorFactory);
+    template(itemType: ApiEnumItemType, params: any): PromiseInterface<ApiResponseProcessor>;
+    create(itemType: ApiEnumItemType, itemId: ItemId, values: any, parentType?: ApiEnumItemType, parentId?: ItemId): PromiseInterface<ApiResponseProcessor>;
+    delete(itemType: ApiEnumItemType, itemIds: ItemId[]): PromiseInterface<ApiResponseProcessor>;
+    updateItems(itemType: ApiEnumItemType, items: ApiRequestItemMap, columns: any): PromiseInterface<ApiResponseProcessor>;
+    requestSkeleton(params: any, requestCanceler?: PromiseInterface<any>): PromiseInterface<ApiResponseProcessor>;
+    moveItems(parentType: ApiEnumItemType, parentId: ItemId, items: {
+        [itemType: string]: ItemId[];
+    }): PromiseInterface<ApiResponseProcessor>;
+    columns(itemType: ApiEnumItemType, columns: ApiRequestColumnMap, params?: any): PromiseInterface<ApiResponseProcessor>;
+    query<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery<ItemTypeType>, columns: ApiRequestColumnMap, limit?: ApiRequestLimit): PromiseInterface<ApiResponseProcessor>;
+    processResponse(request: any): PromiseInterface<ApiResponseProcessor>;
+}

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

@@ -1,29 +1,29 @@
-import { ApiEnumItemType, ItemId, ResponseColumn } from '@rentman/backend-types';
-import { ApiFormatter, ApiResponse, ColumnInfo, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
-export declare class ApiResponseProcessor<RequestItemType extends ApiEnumItemType = any> {
-    apiFormatter: ApiFormatter;
-    response: ApiResponse;
-    itemType: RequestItemType;
-    columns: ItemTypeMap<ResponseColumn[]>;
-    links: ItemTypeMap<ItemId[]>;
-    cacheable: boolean;
-    map: any;
-    items: any;
-    columnIndexMap: {
-        [itemType: string]: {
-            [columnId: string]: number;
-        };
-    };
-    columnMap: any;
-    constructor(apiFormatter: ApiFormatter, response: ApiResponse);
-    fetchColumnObject(itemType: ApiEnumItemType): ResponseColumnMap;
-    fetchValue(itemType: ApiEnumItemType, itemId: ItemId, columnId: string): any;
-    fetchColumnArray(itemType: ApiEnumItemType): ResponseColumn[];
-    fetchDerivedObject(itemType: ApiEnumItemType, itemId: ItemId, rootColumns: ColumnInfo[]): {};
-    fetchDerivedValues(value: any, column: ColumnInfo, destination: any): void;
-    fetchObject<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType> | undefined;
-    fetchObjectArray<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): FieldMap<ItemTypeType>[];
-    fetchColumnsObject(): ResponseColumnItemTypeMap;
-    private addLazyFormattingFunction;
-    private createColumnMaps;
-}
+import { ApiEnumItemType, ItemId, ResponseColumn } from '@rentman/backend-types';
+import { ApiFormatter, ApiResponse, ColumnInfo, FieldMap, ItemTypeMap, ResponseColumnItemTypeMap, ResponseColumnMap } from '../internal';
+export declare class ApiResponseProcessor<RequestItemType extends ApiEnumItemType = any> {
+    apiFormatter: ApiFormatter;
+    response: ApiResponse;
+    itemType: RequestItemType;
+    columns: ItemTypeMap<ResponseColumn[]>;
+    links: ItemTypeMap<ItemId[]>;
+    cacheable: boolean;
+    map: any;
+    items: any;
+    columnIndexMap: {
+        [itemType: string]: {
+            [columnId: string]: number;
+        };
+    };
+    columnMap: any;
+    constructor(apiFormatter: ApiFormatter, response: ApiResponse);
+    fetchColumnObject(itemType: ApiEnumItemType): ResponseColumnMap;
+    fetchValue(itemType: ApiEnumItemType, itemId: ItemId, columnId: string): any;
+    fetchColumnArray(itemType: ApiEnumItemType): ResponseColumn[];
+    fetchDerivedObject(itemType: ApiEnumItemType, itemId: ItemId, rootColumns: ColumnInfo[]): {};
+    fetchDerivedValues(value: any, column: ColumnInfo, destination: any): void;
+    fetchObject<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: string | ItemId): FieldMap<ItemTypeType> | undefined;
+    fetchObjectArray<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, idArray?: ItemId[] | null): FieldMap<ItemTypeType>[];
+    fetchColumnsObject(): ResponseColumnItemTypeMap;
+    private addLazyFormattingFunction;
+    private createColumnMaps;
+}

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

@@ -1,44 +1,44 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
-export declare type CacheSyncerQueryMap = ItemTypeMap<{
-    [cachedQueryString: string]: {
-        cachedQueryItems: CachedQueryItem[];
-        collectionResources: CollectionResource[];
-    };
-}>;
-export declare type CacheSyncerMatches<ItemTypeType extends ApiEnumItemType> = {
-    [itemId: number]: {
-        item: ItemEntry<ItemTypeType>;
-        isMatch: boolean | 'maybe';
-    };
-};
-export declare class CacheSyncer {
-    private queryService;
-    private queryMatcherFactory;
-    private apiRequestService;
-    private promiseService;
-    private transaction;
-    private cachedQueryMap;
-    private matchedItemEntryMap;
-    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
-    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
-    syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
-    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
-    processDelta(parentChangesDelta: ParentChangesDelta): this;
-    groupMatchedItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery): {
-        [key in 'fitting' | 'notFitting' | 'maybe']: ItemEntry<ItemTypeType>[];
-    };
-    _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
-    /**
-     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
-     * by the caller.
-     */
-    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
-    /**
-     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
-     */
-    private resolveAll;
-    private syncCollection;
-    private syncCachedQuery;
-    private addMatchedEntriesToCollections;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestService, CachedQueryItem, ChangesDeltaBase, CollectionQuery, CollectionResource, FieldMap, ItemEntry, ItemTypeMap, ParentChangesDelta, PromiseInterface, PromiseLibraryInterface, QueryMatcherFactory, QueryService } from '../internal';
+export declare type CacheSyncerQueryMap = ItemTypeMap<{
+    [cachedQueryString: string]: {
+        cachedQueryItems: CachedQueryItem[];
+        collectionResources: CollectionResource[];
+    };
+}>;
+export declare type CacheSyncerMatches<ItemTypeType extends ApiEnumItemType> = {
+    [itemId: number]: {
+        item: ItemEntry<ItemTypeType>;
+        isMatch: boolean | 'maybe';
+    };
+};
+export declare class CacheSyncer {
+    private queryService;
+    private queryMatcherFactory;
+    private apiRequestService;
+    private promiseService;
+    private transaction;
+    private cachedQueryMap;
+    private matchedItemEntryMap;
+    constructor(queryService: QueryService, queryMatcherFactory: QueryMatcherFactory, apiRequestService: ApiRequestService, promiseService: PromiseLibraryInterface, transaction: AbstractCache, cachedQueryMap: CacheSyncerQueryMap);
+    syncCollections(isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void>;
+    syncCachedQueries(_isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDeltaBase): PromiseInterface<void[]>;
+    expand<ItemEntryType extends ItemEntry>(itemEntry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>): this;
+    processDelta(parentChangesDelta: ParentChangesDelta): this;
+    groupMatchedItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery): {
+        [key in 'fitting' | 'notFitting' | 'maybe']: ItemEntry<ItemTypeType>[];
+    };
+    _expand<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, matchFunction: (itemType: ItemTypeType, parsedQuery: CollectionQuery) => boolean | 'maybe'): this;
+    /**
+     * Unlike the functions that use a promise accumulator, this function *can* result in a rejection. It should be handled
+     * by the caller.
+     */
+    protected processMaybeMatches<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: CollectionQuery, maybeItemEntries: ItemEntry<ItemTypeType>[], changesDelta: ChangesDeltaBase | undefined): PromiseInterface<ItemEntry<ItemTypeType>[]>;
+    /**
+     * Returns null if none of the promises resulted in an exception, or the exception otherwise.
+     */
+    private resolveAll;
+    private syncCollection;
+    private syncCachedQuery;
+    private addMatchedEntriesToCollections;
+}

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

@@ -1,33 +1,33 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { InternalCreateDelta, ItemEntry, ItemEntryMap, ItemMap, TransactionCache } from '../internal';
-export declare type CreateRequestCompilationParent = ApiEnumItemType | 'Void';
-export declare type CreateCompilation = {
-    [parentType: string]: {
-        [parentId: number]: ItemMap<InternalCreateDelta>;
-    };
-};
-export declare type DeleteCompilation = {
-    [itemType: string]: ItemEntry[];
-};
-export declare type UpdateCompilation = ItemEntryMap;
-export declare type MoveCompilation = {
-    [parentType: string]: {
-        [parentId: number]: ItemEntry[];
-    };
-};
-export declare class ChangesCompilation {
-    private transaction;
-    compilation: {
-        create: CreateCompilation;
-        delete: DeleteCompilation;
-        update: UpdateCompilation;
-        move: MoveCompilation;
-    };
-    constructor(transaction: TransactionCache);
-    private processDelta;
-    private getDefaultParent;
-    private addMoveEntry;
-    private addDeleteEntry;
-    private addUpdateEntry;
-    private addCreateEntry;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { InternalCreateDelta, ItemEntry, ItemEntryMap, ItemMap, TransactionCache } from '../internal';
+export declare type CreateRequestCompilationParent = ApiEnumItemType | 'Void';
+export declare type CreateCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemMap<InternalCreateDelta>;
+    };
+};
+export declare type DeleteCompilation = {
+    [itemType: string]: ItemEntry[];
+};
+export declare type UpdateCompilation = ItemEntryMap;
+export declare type MoveCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemEntry[];
+    };
+};
+export declare class ChangesCompilation {
+    private transaction;
+    compilation: {
+        create: CreateCompilation;
+        delete: DeleteCompilation;
+        update: UpdateCompilation;
+        move: MoveCompilation;
+    };
+    constructor(transaction: TransactionCache);
+    private processDelta;
+    private getDefaultParent;
+    private addMoveEntry;
+    private addDeleteEntry;
+    private addUpdateEntry;
+    private addCreateEntry;
+}

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

@@ -1,61 +1,61 @@
-import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
-import { ApiFormatter, ChangesDeltaBase, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
-export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
-/**
- * @description
- * ChangesDelta used to apply changes from outside of the core to a transaction
- *
- * ----------
- *
- * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ChangesDelta
- * assumes 'created' values have no itemEntries yet.
- *
- * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
- */
-export declare class ChangesDelta extends ChangesDeltaBase {
-    private errorHandler;
-    private itemCreateService;
-    created: CreatedChangesDelta;
-    deleted: {
-        [itemType: string]: ChangesDeltaItemDeleteDelta[];
-    };
-    constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
-    /**
-     * @description
-     * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
-     *
-     * @remark
-     * - If the values don't contain an `id` a new one will be generated
-     * - If you want to set a parent set the proper field, you can't pass it as a separate object
-     */
-    setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemType: ItemTypeType, values: Fields): PromiseInterface<this>;
-    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
-    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
-    /**
-     * @description
-     * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
-     *
-     * @remark
-     * - If the values don't contain an `id` a new one will be generated
-     * - If you want to set a parent set the proper field, you can't pass it as a separate object
-     */
-    setItemsCreated<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<this>;
-    /**
-     * @description
-     * Will create an {@link ItemEntry ItemEntry} when the delta is applied
-     * Does not always mean the item is local, just that it isn't cached yet
-     *
-     * @remark
-     * If you're calling this from the frontend you probably want to call `setItemCreated`, which will fetch a template and process the values for you
-     * If you don't, you have to make sure the values are all correct and all template items are processed
-     *
-     * @internal
-     */
-    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean): this;
-    /**
-     * @description
-     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
-     */
-    setItemMoved(entry: ItemEntry, to: EntryParent, updateModified?: boolean, updateInitial?: boolean): this;
-    isEmpty(): boolean;
-}
+import { ApiEnumItemType, ApiFields, ItemId } from '@rentman/backend-types';
+import { ApiFormatter, ChangesDeltaBase, ColumnSet, CreatedChangesDelta, EntryParent, EntryParentNull, ErrorHandlerInterface, FieldMap, ItemCreateService, ItemEntry, ItemEntryService, PromiseInterface } from '../internal';
+export declare type ChangesDeltaItemDeleteDelta = ItemEntry;
+/**
+ * @description
+ * ChangesDelta used to apply changes from outside of the core to a transaction
+ *
+ * ----------
+ *
+ * The difference between {@link InternalChangesDelta InternalChangesDelta} and {@link ChangesDelta ChangesDelta} is that the ChangesDelta
+ * assumes 'created' values have no itemEntries yet.
+ *
+ * Use this when calling {@link TransactionCache.applyChangesDelta applyChangesDelta}
+ */
+export declare class ChangesDelta extends ChangesDeltaBase {
+    private errorHandler;
+    private itemCreateService;
+    created: CreatedChangesDelta;
+    deleted: {
+        [itemType: string]: ChangesDeltaItemDeleteDelta[];
+    };
+    constructor(errorHandler: ErrorHandlerInterface, itemCreateService: ItemCreateService, itemEntryService: ItemEntryService, apiFormatter: ApiFormatter);
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the item to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends Partial<FieldMap<ItemTypeType>>>(itemType: ItemTypeType, values: Fields): PromiseInterface<this>;
+    setItemDeleted(deleted: ChangesDeltaItemDeleteDelta): this;
+    setItemsDeleted(deleted: ChangesDeltaItemDeleteDelta[]): this;
+    /**
+     * @description
+     * Fetches a template for the passed itemType and processes the passed values and sets the items to be created when the delta is applied
+     *
+     * @remark
+     * - If the values don't contain an `id` a new one will be generated
+     * - If you want to set a parent set the proper field, you can't pass it as a separate object
+     */
+    setItemsCreated<ItemTypeType extends ApiEnumItemType, ColumnIds extends (keyof ApiFields[ItemTypeType])[] = (keyof ApiFields[ItemTypeType])[]>(itemType: ItemTypeType, valuesArray: Partial<FieldMap<ItemTypeType, ColumnIds>>[]): PromiseInterface<this>;
+    /**
+     * @description
+     * Will create an {@link ItemEntry ItemEntry} when the delta is applied
+     * Does not always mean the item is local, just that it isn't cached yet
+     *
+     * @remark
+     * If you're calling this from the frontend you probably want to call `setItemCreated`, which will fetch a template and process the values for you
+     * If you don't, you have to make sure the values are all correct and all template items are processed
+     *
+     * @internal
+     */
+    _setItemCreated<ItemTypeType extends ApiEnumItemType, Fields extends FieldMap<ItemTypeType>>(itemId: ItemId, fields: Fields, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull, isRoot?: boolean): this;
+    /**
+     * @description
+     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent, updateModified?: boolean, updateInitial?: boolean): this;
+    isEmpty(): boolean;
+}