@rentman/rm-core 2.0.11 → 2.0.13

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

@@ -1,55 +1,55 @@
-import * as moment from 'moment';
-import { ColumnInfo } from '../classes';
-import { FieldMap, ItemType } from '../types';
-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: string): boolean;
-    /**
-     * @description
-     * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
-     */
-    mergeCopyFields<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, changes: FieldMap<ItemTypeType>, newInitial: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
-    formatRequest<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    formatRequestLocal<ItemTypeType extends ItemType>(fields: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>, includeReadOnlyColumns?: boolean): boolean;
-    getChanges<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    copyFields<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
-    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
-    /**
-     * @description
-     * Compares the given fields, returns `true` when the fields are equal
-     */
-    compareFields(columnType: string, first?: any, second?: any): 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: string): any;
-    isDefaultValue(columnType: string, 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;
-}
+import * as moment from 'moment';
+import { ColumnInfo } from '../classes';
+import { FieldMap, ItemType } from '../types';
+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: string): boolean;
+    /**
+     * @description
+     * Overwrites the values in 'changes' if the values in 'initial' and 'changes' are the same (leaving user changes intact)
+     */
+    mergeCopyFields<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, changes: FieldMap<ItemTypeType>, newInitial: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<ItemTypeType>>): FieldMap<ItemTypeType>;
+    formatRequest<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    formatRequestLocal<ItemTypeType extends ItemType>(fields: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    hasChanges(initial: FieldMap, modified: FieldMap, columns: Array<ColumnInfo<any>>): boolean;
+    getChanges<ItemTypeType extends ItemType>(initial: FieldMap<ItemTypeType>, modified: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    copyFields<ItemTypeType extends ItemType>(source: FieldMap<ItemTypeType>, destination: FieldMap<ItemTypeType>, columns: Array<ColumnInfo<any>>): FieldMap<ItemTypeType>;
+    shallowCopyFields(shallowSource: FieldMap, deepSource: FieldMap, destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    setDefaultValues(destination: FieldMap, columns: Array<ColumnInfo<any>>): FieldMap;
+    /**
+     * @description
+     * Compares the given fields, returns `true` when the fields are equal
+     */
+    compareFields(columnType: string, first?: any, second?: any): 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: string): any;
+    isDefaultValue(columnType: string, 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;
+}

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

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

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

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

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

@@ -1,34 +1,34 @@
-import { ItemEntry } from '../models';
-import { ItemEntryMap, ItemMap, ItemType } from '../types';
-import { TransactionCache } from './cache/transaction/TransactionCache';
-import { InternalCreateDelta } from './InternalChangesDelta';
-export declare type CreateCompilation = {
-    [parentType: string]: {
-        [parentId: number]: ItemMap<InternalCreateDelta>;
-    };
-};
-export declare type DeleteCompilation = {
-    [itemType: string]: Array<ItemEntry<ItemType>>;
-};
-export declare type UpdateCompilation = ItemEntryMap<ItemType>;
-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 { ItemEntry } from '../models';
+import { ItemEntryMap, ItemMap, ItemType } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
+import { InternalCreateDelta } from './InternalChangesDelta';
+export declare type CreateCompilation = {
+    [parentType: string]: {
+        [parentId: number]: ItemMap<InternalCreateDelta>;
+    };
+};
+export declare type DeleteCompilation = {
+    [itemType: string]: Array<ItemEntry<ItemType>>;
+};
+export declare type UpdateCompilation = ItemEntryMap<ItemType>;
+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/src/classes/ChangesDelta.d.ts

@@ -1,42 +1,42 @@
-import { ItemEntry } from '../models';
-import { EntryParent, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
-import { ChangesDeltaBase } from './ChangesDeltaBase';
-import { ColumnSet } from './ColumnSet';
-import { ItemEntryService } from './ItemEntryService';
-export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
-    itemId: ItemId;
-    fields: FieldMap<ItemTypeType>;
-    columns: ColumnSet<ItemTypeType>;
-};
-/**
- * @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 {
-    created: ChangesDeltaItemCreateDelta[];
-    constructor(itemEntryService: ItemEntryService);
-    /**
-     * @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
-     * When the `parent` property is passed it will automatically set the proper fields to match the parent, this assumes the required parent columns are in the passed columns
-     * You can easily get the required columns by also passing the `parent` to the {@link TemplateCache.fetchTemplate template fetchCollectionEntry} call
-     */
-    setItemCreated<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): void;
-    /**
-     * @description
-     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
-     */
-    setItemMoved(entry: ItemEntry, to: EntryParent): void;
-}
+import { ItemEntry } from '../models';
+import { EntryParent, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
+import { ChangesDeltaBase } from './ChangesDeltaBase';
+import { ColumnSet } from './ColumnSet';
+import { ItemEntryService } from './ItemEntryService';
+export declare type ChangesDeltaItemCreateDelta<ItemTypeType extends ItemType = any> = {
+    itemId: ItemId;
+    fields: FieldMap<ItemTypeType>;
+    columns: ColumnSet<ItemTypeType>;
+};
+/**
+ * @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 {
+    created: ChangesDeltaItemCreateDelta[];
+    constructor(itemEntryService: ItemEntryService);
+    /**
+     * @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
+     * When the `parent` property is passed it will automatically set the proper fields to match the parent, this assumes the required parent columns are in the passed columns
+     * You can easily get the required columns by also passing the `parent` to the {@link TemplateCache.fetchTemplate template fetchCollectionEntry} call
+     */
+    setItemCreated<ItemTypeType extends ItemType>(itemId: ItemId, fields: FieldMap<ItemTypeType>, columns: ColumnSet<ItemTypeType>, parent?: EntryParentNull): void;
+    /**
+     * @description
+     * Convenience function to assign the proper parent fields, will call {@link ChangesDeltaBase.setItemUpdated setItemUpdated} internally
+     */
+    setItemMoved(entry: ItemEntry, to: EntryParent): void;
+}

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

@@ -1,33 +1,33 @@
-import { ItemEntry } from '../models';
-import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemType } from '../types';
-import { ItemEntryService } from './ItemEntryService';
-export declare type ChangesDeltaResult = {
-    rollback: () => void;
-    created: ItemEntry[];
-};
-/**
- * @remark
- * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
- */
-export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ItemType = any> = {
-    entry: ItemEntry<ItemTypeType>;
-    changes: {
-        expandedColumns: ColumnExpansionResult<ItemTypeType> | null;
-        fields: FieldMap<ItemTypeType>;
-        parent: EntryParentNull;
-    };
-};
-export declare type ChangesDeltaItemDeleteDelta = ItemEntry[];
-export declare abstract class ChangesDeltaBase {
-    protected itemEntryService: ItemEntryService;
-    updated: {
-        [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
-    };
-    deleted: {
-        [itemType: string]: ChangesDeltaItemDeleteDelta;
-    };
-    protected constructor(itemEntryService: ItemEntryService);
-    setItemUpdated<ItemEntryType extends ItemEntry>(entry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>, columnExpansionResult?: ColumnExpansionResult<ItemEntryType['itemType']> | null, parent?: EntryParentNull): void;
-    setItemDeleted(deleted: ItemEntry): void;
-    setItemsDeleted(deleted: ItemEntry[]): void;
-}
+import { ItemEntry } from '../models';
+import { ColumnExpansionResult, EntryParentNull, FieldMap, ItemType } from '../types';
+import { ItemEntryService } from './ItemEntryService';
+export declare type ChangesDeltaResult = {
+    rollback: () => void;
+    created: ItemEntry[];
+};
+/**
+ * @remark
+ * We explicitly keep track of the new parent, so we can set an item to moved if it isn't null (Needed for linkTo request)
+ */
+export declare type ChangesDeltaItemUpdateDelta<ItemTypeType extends ItemType = any> = {
+    entry: ItemEntry<ItemTypeType>;
+    changes: {
+        expandedColumns: ColumnExpansionResult<ItemTypeType> | null;
+        fields: FieldMap<ItemTypeType>;
+        parent: EntryParentNull;
+    };
+};
+export declare type ChangesDeltaItemDeleteDelta = ItemEntry[];
+export declare abstract class ChangesDeltaBase {
+    protected itemEntryService: ItemEntryService;
+    updated: {
+        [itemEntryId: number]: ChangesDeltaItemUpdateDelta;
+    };
+    deleted: {
+        [itemType: string]: ChangesDeltaItemDeleteDelta;
+    };
+    protected constructor(itemEntryService: ItemEntryService);
+    setItemUpdated<ItemEntryType extends ItemEntry>(entry: ItemEntryType, fields: FieldMap<ItemEntryType['itemType']>, columnExpansionResult?: ColumnExpansionResult<ItemEntryType['itemType']> | null, parent?: EntryParentNull): void;
+    setItemDeleted(deleted: ItemEntry): void;
+    setItemsDeleted(deleted: ItemEntry[]): void;
+}

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

@@ -1,47 +1,47 @@
-import { ApiRequestService, CollectionEntryService, ItemEntryService } from '../classes';
-import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
-import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
-import { ItemIdConversionMap, PromiseInterface } from '../types';
-import { TransactionCache } from './cache/transaction/TransactionCache';
-export declare type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
-/**
- * @description
- * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
- */
-export declare class ChangesProcessor {
-    private changesDeltaFactory;
-    private apiRequestService;
-    private changesCompilationFactory;
-    private columnExpansionFactory;
-    private createRequestFactory;
-    private errorHandler;
-    private promiseService;
-    private requestColumnExpansionFactory;
-    private collectionEntryService;
-    private itemEntryService;
-    private transaction;
-    private breakUpByParent?;
-    private onAfterCreateCallback?;
-    private itemIdConversionMap;
-    private serverCache;
-    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
-    /**
-     * @description
-     * Executes the requests in the order of:
-     * 1. create
-     * 2. move
-     * 3. delete
-     * 4. update
-     */
-    execute(): PromiseInterface<ItemIdConversionMap>;
-    private buildMoveRequest;
-    private getMapValue;
-    private executeCreateRequests;
-    private executeCreateRequest;
-    private executeUpdateRequests;
-    private executeUpdateRequest;
-    private executeDeleteRequests;
-    private executeDeleteRequest;
-    private executeMoveRequests;
-}
+import { ApiRequestService, CollectionEntryService, ItemEntryService } from '../classes';
+import { ChangesCompilationFactory, ColumnExpansionFactory, CreateRequestFactory, RequestColumnExpansionFactory } from '../factories';
+import { ChangesDeltaFactory } from '../factories/ChangesDeltaFactory';
+import { ErrorHandlerInterface, PromiseLibraryInterface } from '../interfaces';
+import { ItemIdConversionMap, PromiseInterface } from '../types';
+import { TransactionCache } from './cache/transaction/TransactionCache';
+export declare type OnAfterCreateCallback = (conversionMap: ItemIdConversionMap) => void;
+/**
+ * @description
+ * Executes the changes from a specific {@link TransactionCache transaction} and returns a {@link ChangesDelta ChangesDelta}
+ */
+export declare class ChangesProcessor {
+    private changesDeltaFactory;
+    private apiRequestService;
+    private changesCompilationFactory;
+    private columnExpansionFactory;
+    private createRequestFactory;
+    private errorHandler;
+    private promiseService;
+    private requestColumnExpansionFactory;
+    private collectionEntryService;
+    private itemEntryService;
+    private transaction;
+    private breakUpByParent?;
+    private onAfterCreateCallback?;
+    private itemIdConversionMap;
+    private serverCache;
+    constructor(changesDeltaFactory: ChangesDeltaFactory, apiRequestService: ApiRequestService, changesCompilationFactory: ChangesCompilationFactory, columnExpansionFactory: ColumnExpansionFactory, createRequestFactory: CreateRequestFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, requestColumnExpansionFactory: RequestColumnExpansionFactory, collectionEntryService: CollectionEntryService, itemEntryService: ItemEntryService, transaction: TransactionCache, breakUpByParent?: boolean | undefined, onAfterCreateCallback?: OnAfterCreateCallback | undefined);
+    /**
+     * @description
+     * Executes the requests in the order of:
+     * 1. create
+     * 2. move
+     * 3. delete
+     * 4. update
+     */
+    execute(): PromiseInterface<ItemIdConversionMap>;
+    private buildMoveRequest;
+    private getMapValue;
+    private executeCreateRequests;
+    private executeCreateRequest;
+    private executeUpdateRequests;
+    private executeUpdateRequest;
+    private executeDeleteRequests;
+    private executeDeleteRequest;
+    private executeMoveRequests;
+}

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

@@ -1,37 +1,37 @@
-import { QueryMatcherFactory } from '../factories';
-import { CollectionEntry, CollectionResource } from '../models';
-import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
-import { AbstractCache } from './cache/AbstractCache';
-export declare class CollectionCache {
-    private queryMatcherFactory;
-    private transaction;
-    private entries;
-    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
-    getByEntryId(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
-    contains(collectionEntry: CollectionEntry<any>): boolean;
-    some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
-    forEach(callback: (entry: CollectionEntry<any>) => void): void;
-    toArray(): CollectionEntry<any>[];
-    add<T extends CollectionEntry<any>>(collectionEntry: T): T;
-    clear(collectionEntry?: CollectionEntry<any>): boolean;
-    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): CollectionEntry<ItemTypeType>[];
-    matchParent(collectionEntry: CollectionEntry<any>, itemType: string, itemId: ItemId): boolean;
-    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionEntry<ItemTypeType> | null;
-    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry<any>[];
-    /**
-     * @description
-     * Gets {@link CollectionEntry CollectionEntries} which contain the item with the passed ItemType/ItemId
-     */
-    getByContainingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId): CollectionEntry<ItemTypeType>[];
-    /**
-     * @description
-     * Checks if the passed fields would fit in the collections using the {@link QueryMatcher QueryMatcher}
-     */
-    getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
-    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
-    getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
-    /**
-     * @deprecated
-     */
-    getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
-}
+import { QueryMatcherFactory } from '../factories';
+import { CollectionEntry, CollectionResource } from '../models';
+import { CollectionMatchResult, CollectionQuery, EntryParentNull, FieldMap, ItemId, ItemType } from '../types';
+import { AbstractCache } from './cache/AbstractCache';
+export declare class CollectionCache {
+    private queryMatcherFactory;
+    private transaction;
+    private entries;
+    constructor(queryMatcherFactory: QueryMatcherFactory, transaction: AbstractCache);
+    getByEntryId(collectionEntryId: CollectionEntry['id']): CollectionEntry | undefined;
+    contains(collectionEntry: CollectionEntry<any>): boolean;
+    some(callback: (entry: CollectionEntry<any>) => boolean): boolean;
+    forEach(callback: (entry: CollectionEntry<any>) => void): void;
+    toArray(): CollectionEntry<any>[];
+    add<T extends CollectionEntry<any>>(collectionEntry: T): T;
+    clear(collectionEntry?: CollectionEntry<any>): boolean;
+    getByItemType<ItemTypeType extends ItemType>(itemType: ItemTypeType): CollectionEntry<ItemTypeType>[];
+    matchParent(collectionEntry: CollectionEntry<any>, itemType: string, itemId: ItemId): boolean;
+    getByParent<ItemTypeType extends ItemType>(parentType: ItemType, parentId: ItemId, itemType: ItemTypeType): CollectionEntry<ItemTypeType> | null;
+    getCollectionsByParent(parentType: ItemType, parentId: ItemId): CollectionEntry<any>[];
+    /**
+     * @description
+     * Gets {@link CollectionEntry CollectionEntries} which contain the item with the passed ItemType/ItemId
+     */
+    getByContainingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, itemId: ItemId): CollectionEntry<ItemTypeType>[];
+    /**
+     * @description
+     * Checks if the passed fields would fit in the collections using the {@link QueryMatcher QueryMatcher}
+     */
+    getByFittingItem<ItemTypeType extends ItemType>(itemType: ItemTypeType, fields: FieldMap, parent: EntryParentNull): CollectionMatchResult<ItemTypeType>;
+    getByQuery<ItemTypeType extends ItemType>(itemType: ItemTypeType, query: CollectionQuery): CollectionEntry<ItemTypeType> | null;
+    getByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, entryKey: string): Array<CollectionEntry<ItemTypeType>>;
+    /**
+     * @deprecated
+     */
+    getResourceByKey<ItemTypeType extends ItemType>(itemType: ItemTypeType, resourceKey: string): Array<CollectionResource<ItemTypeType>>;
+}