@rentman/rm-core 8.1.6 → 8.1.8-dev1

package/dist/types/classes/cache/server/ServerCache.d.ts

@@ -1,94 +1,82 @@
-import { ApiEnumItemType } from '@rentman/backend-types';
-import { ChangesDelta, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../..';
-import { RmCore } from '../../../core';
-import { ServerCacheDependencyInterface } from '../../../interfaces/ServerCacheDependencyInterface';
-import { ItemEntry } from '../../../models';
-import { ApiRequestColumn, ApiRequestColumnMap, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemIdConversionMap, ItemTypeMap, PromiseInterface } from '../../../types';
-import { ApiResponseProcessor } from '../../ApiResponseProcessor';
-import { ChangesDeltaResult } from '../../ChangesDeltaBase';
-import { OnAfterCreateCallback } from '../../ChangesProcessor';
-import { ParentChangesDelta } from '../../ParentChangesDelta';
-import { AbstractCache } from '../AbstractCache';
-import { CachedQueryItem } from '../CachedQueryHandlerBase';
-import { ServerCachedQueryHandler } from './ServerCachedQueryHandler';
-import { ServerItemEntryChanges, ServerItemHandler } from './ServerItemHandler';
-/**
- * @description
- * The {@link ServerCache ServerCache} is responsible for keeping track of {@link ItemEntry ItemEntries} and {@link CollectionEntry CollectionEntries}
- * which are saved on the server.
- *
- * It's basically a local representation of the database
- */
-export declare class ServerCache extends AbstractCache {
-    dependencies: ServerCacheDependencyInterface;
-    readonly itemHandler: ServerItemHandler;
-    readonly cachedQueryHandler: ServerCachedQueryHandler;
-    parent: null;
-    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
-    getServerCache(): ServerCache;
-    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
-    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
-    /**
-     *
-     * @param response
-     * @param requestColumnMap
-     * @param isCalledAfterSocketUpdate
-     * @param changesDelta
-     * @param conversionMap
-     * @param directRequestItemMap Should be a map of ItemType->ItemId of items that were directly part of the create/update request (queries should be excluded from this because we don't want to overwrite the user's changes (derived values are also queries))
-     */
-    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, directRequestItemMap?: ItemTypeMap<Record<string, boolean>>, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
-    /**
-     * @description
-     * Applies changes to this transaction and its children
-     * ServerCache.applyChangesFromParent should be used when processing an API update/create/delete
-     */
-    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
-    /**
-     * @description
-     * Gets the fields required to set the parent
-     */
-    getLinkFieldsByParent<ItemTypeType extends ApiEnumItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
-    /**
-     * @description
-     * Gets the entry's parent
-     *
-     * @param itemEntry The entry to get the parent from
-     * @param _fromInitial Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
-     * @param _providedFields Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
-     *
-     * @remark
-     * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
-     */
-    getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
-    getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
-    /**
-     * @description
-     * Only takes the local changes into account, used for saving
-     */
-    getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): {
-        entry: ItemEntry;
-        changes: ServerItemEntryChanges;
-    };
-    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
-    /**
-     * @description
-     * Invalidates the complete server cache, all items will be re-fetched whenever they are requested
-     */
-    invalidateCache(): void;
-    /**
-     * @description
-     * Merges the passed changes from the child Transaction into this Transaction's own changes and then propagates
-     * them to all child Transactions
-     */
-    applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
-    /**
-     * @description
-     * Applies changes to this transaction and its children
-     * ServerCache.applyChangesDelta should be used when processing an API response which should create new entries on the ServerCache (such as a Query)
-     */
-    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
-    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
-    getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
-    getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
-}
+import { ApiEnumItemType } from '@rentman/backend-types';
+import { AbstractCache, ApiRequestColumn, ApiRequestColumnMap, ApiResponseProcessor, CachedQueryItem, ChangesDelta, ChangesDeltaResult, CollectionQuery, CollectionResourceParentIdMap, EntryParent, EntryParentNull, FieldMap, ItemEntry, ItemIdConversionMap, ItemTypeMap, OnAfterCreateCallback, ParentChangesDelta, PromiseInterface, RmCore, ServerCacheDependencyInterface, ServerCachedQueryHandler, ServerItemEntryChanges, ServerItemHandler, TransactionCache, TransactionOptions, TransactionValidatorFactory } from '../../../internal';
+/**
+ * @description
+ * The {@link ServerCache ServerCache} is responsible for keeping track of {@link ItemEntry ItemEntries} and {@link CollectionEntry CollectionEntries}
+ * which are saved on the server.
+ *
+ * It's basically a local representation of the database
+ */
+export declare class ServerCache extends AbstractCache {
+    dependencies: ServerCacheDependencyInterface;
+    readonly itemHandler: ServerItemHandler;
+    readonly cachedQueryHandler: ServerCachedQueryHandler;
+    parent: null;
+    constructor(dependencies: ServerCacheDependencyInterface, core: RmCore);
+    getServerCache(): ServerCache;
+    createChild(id?: string, validatorFactory?: TransactionValidatorFactory, options?: TransactionOptions): TransactionCache;
+    expandCollectionResources<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, collections: CollectionResourceParentIdMap<ItemTypeType>, newRequestColumns: ApiRequestColumn[]): PromiseInterface<CollectionResourceParentIdMap>;
+    /**
+     *
+     * @param response
+     * @param requestColumnMap
+     * @param isCalledAfterSocketUpdate
+     * @param changesDelta
+     * @param conversionMap
+     * @param directRequestItemMap Should be a map of ItemType->ItemId of items that were directly part of the create/update request (queries should be excluded from this because we don't want to overwrite the user's changes (derived values are also queries))
+     */
+    processResponse(response: ApiResponseProcessor, requestColumnMap: ApiRequestColumnMap, isCalledAfterSocketUpdate?: boolean, changesDelta?: ChangesDelta, directRequestItemMap?: ItemTypeMap<Record<string, boolean>>, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
+    /**
+     * @description
+     * Applies changes to this transaction and its children
+     * ServerCache.applyChangesFromParent should be used when processing an API update/create/delete
+     */
+    applyChangesFromParent(parentChangesDelta: ParentChangesDelta, isCalledAfterSocketUpdate?: boolean): PromiseInterface<void>;
+    /**
+     * @description
+     * Gets the fields required to set the parent
+     */
+    getLinkFieldsByParent<ItemTypeType extends ApiEnumItemType>(parent: EntryParent, itemType: ItemTypeType): Partial<FieldMap<ItemTypeType>>;
+    /**
+     * @description
+     * Gets the entry's parent
+     *
+     * @param itemEntry The entry to get the parent from
+     * @param _fromInitial Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
+     * @param _providedFields Unused parameter, there for alignment with {@link TransactionCache.getParent TransactionCache.getParent]
+     *
+     * @remark
+     * Use {@link CollectionResource.getParent CollectionResource.getParent} instead of {@link TransactionCache.getParent TransactionCache.getParent} if you're getting the parent in the onRemove callback
+     */
+    getParent<ItemTypeType extends ApiEnumItemType = any>(itemEntry: ItemEntry<ItemTypeType>, _fromInitial?: boolean, _providedFields?: FieldMap<ItemTypeType>): EntryParentNull;
+    getItemChangesRecursively(itemEntryId: ItemEntry['id'], copyFields?: boolean): FieldMap;
+    /**
+     * @description
+     * Only takes the local changes into account, used for saving
+     */
+    getLocalItemEntryChangesTuple(itemEntryId: ItemEntry['id']): {
+        entry: ItemEntry;
+        changes: ServerItemEntryChanges;
+    };
+    getCollectionChangesRecursively<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, parsedQuery: CollectionQuery): CachedQueryItem<ItemTypeType> | undefined;
+    /**
+     * @description
+     * Invalidates the complete server cache, all items will be re-fetched whenever they are requested
+     */
+    invalidateCache(): void;
+    /**
+     * @description
+     * Merges the passed changes from the child Transaction into this Transaction's own changes and then propagates
+     * them to all child Transactions
+     */
+    applyChangesFromChild(transaction: TransactionCache, breakUpByParent?: boolean, onAfterCreateCallback?: OnAfterCreateCallback): PromiseInterface<ItemIdConversionMap>;
+    /**
+     * @description
+     * Applies changes to this transaction and its children
+     * ServerCache.applyChangesDelta should be used when processing an API response which should create new entries on the ServerCache (such as a Query)
+     */
+    applyChangesDelta(changesDelta: ChangesDelta, isCalledAfterSocketUpdate?: boolean, conversionMap?: ItemIdConversionMap): PromiseInterface<ChangesDeltaResult>;
+    getLocalItemEntry(itemEntryId: ItemEntry['id']): ItemEntry | undefined;
+    getLocalItemEntryByItemId(itemType: ApiEnumItemType, itemId: ItemEntry['itemId']): ItemEntry | undefined;
+    getChangesFromItemChanges<ItemTypeType extends ApiEnumItemType = any>(changesObject: ServerItemEntryChanges<ItemTypeType>): FieldMap<ItemTypeType>;
+}

package/dist/types/classes/cache/server/ServerCachedQueryHandler.d.ts

@@ -1,34 +1,25 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ColumnSubsetCacheFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ApiRequestColumns, ApiRequestService, CollectionQuery, ColumnSubsetCache, ColumnUtil, ParentIdMap, PromiseInterface } from '../../../index';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry } from '../../../models';
-import { CollectionOptions } from '../../../models/CollectionOptions';
-import { CollectionEntryService } from '../../index';
-import { RequestBufferManager } from '../../RequestBufferManager';
-import { CachedQueryHandlerBase, CachedQueryItem } from '../CachedQueryHandlerBase';
-import { ServerCache } from './ServerCache';
-import { ServerItemHandler } from './ServerItemHandler';
-export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
-    private columnSubsetCacheFactory;
-    private requestBufferManager;
-    private apiRequestService;
-    private errorHandler;
-    private itemHandler;
-    protected transaction: ServerCache;
-    constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, transaction: ServerCache);
-    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
-    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
-    /**
-     * @description
-     * Expands the columns of the items in the cached query
-     */
-    __expandCachedQuery<ItemTypeType extends ApiEnumItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/options, will do nothing if the requested CollectionEntry/columns are already cached.
-     * Will create a new {@link CollectionEntry CollectionEntry} if the CollectionEntry didn't exist yet
-     */
-    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiRequestColumns, ApiRequestService, CachedQueryHandlerBase, CachedQueryItem, CollectionEntryService, CollectionOptions, CollectionQuery, ColumnSubsetCache, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, ItemEntry, ParentIdMap, PromiseInterface, PromiseLibraryInterface, RequestBufferManager, RequestColumnExpansionFactory, ServerCache, ServerItemHandler } from '../../../internal';
+export declare class ServerCachedQueryHandler extends CachedQueryHandlerBase {
+    private columnSubsetCacheFactory;
+    private requestBufferManager;
+    private apiRequestService;
+    private errorHandler;
+    private itemHandler;
+    protected transaction: ServerCache;
+    constructor(columnSubsetCacheFactory: ColumnSubsetCacheFactory, requestBufferManager: RequestBufferManager, requestColumnExpansionFactory: RequestColumnExpansionFactory, apiRequestService: ApiRequestService, collectionEntryService: CollectionEntryService, errorHandler: ErrorHandlerInterface, itemHandler: ServerItemHandler, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, transaction: ServerCache);
+    __fetchCachedQueryItem<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    __fetchLinkedCachedQueryItems<ItemTypeType extends ApiEnumItemType>(parentType: ApiEnumItemType, parentIdArray: ItemId[] | (() => ItemId[]), itemType: ItemTypeType, options: CollectionOptions): PromiseInterface<ParentIdMap<CachedQueryItem<ItemTypeType>>>;
+    __addItemEntriesToCachedQueries<ItemTypeType extends ApiEnumItemType = any>(itemType: ItemTypeType, parsedQuery: CollectionQuery, itemEntries: Array<ItemEntry<ItemTypeType>>): void;
+    /**
+     * @description
+     * Expands the columns of the items in the cached query
+     */
+    __expandCachedQuery<ItemTypeType extends ApiEnumItemType = any>(cachedQuery: CachedQueryItem<ItemTypeType>, newColumns: ApiRequestColumns, force?: boolean): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/options, will do nothing if the requested CollectionEntry/columns are already cached.
+     * Will create a new {@link CollectionEntry CollectionEntry} if the CollectionEntry didn't exist yet
+     */
+    __fetchItemEntriesByQueryData<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, options: CollectionOptions<ItemTypeType>, columnSubsetCache: ColumnSubsetCache<ItemTypeType>, collectionQuery: CollectionQuery): PromiseInterface<CachedQueryItem<ItemTypeType>>;
+}

package/dist/types/classes/cache/server/ServerItemHandler.d.ts

@@ -1,53 +1,44 @@
-import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
-import { ColumnSubsetCacheFactory, ItemCacheFactory, ItemEntryFactory, QueryParserFactory, RequestColumnExpansionFactory } from '../../../factories';
-import { ErrorHandlerInterface, PromiseLibraryInterface } from '../../../interfaces';
-import { ItemEntry, ItemEntryOptions } from '../../../models';
-import { ApiQuery, ApiRequestColumns, FieldMap, PromiseInterface } from '../../../types';
-import { ChangesDelta } from '../../ChangesDelta';
-import { ChangesDeltaItemUpdateDelta } from '../../ChangesDeltaBase';
-import { ChangesDeltaItemCreateDelta } from '../../CreatedChangesDelta';
-import { ApiFormatter, ApiResponseProcessor, ColumnExpansion, ColumnSet, ColumnUtil, QueryService, RequestBufferManager, RequestBufferResponse, TransactionItemEntryChanges } from '../../index';
-import { ItemHandlerBase, ProcessItemEntryChangesResult } from '../ItemHandlerBase';
-import { ServerCache } from './ServerCache';
-export declare type ServerItemEntryChanges<ItemTypeType extends ApiEnumItemType = any> = FieldMap<ItemTypeType>;
-export declare class ServerItemHandler extends ItemHandlerBase {
-    private requestBufferManager;
-    private queryParserFactory;
-    private queryService;
-    private columnSubsetCacheFactory;
-    protected transaction: ServerCache;
-    itemChanges: {
-        [itemEntryId: number]: ServerItemEntryChanges;
-    };
-    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
-    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
-    /**
-     * @description
-     * Processes updates on a cached entry
-     */
-    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
-    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): ServerItemEntryChanges;
-    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
-    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    extendItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, newColumns: ApiRequestColumns): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
-    /**
-     * @description
-     * Fetches the data for the ItemEntries linked to the parent Items
-     *
-     * @param columns should contain a derived column that refers to the parent
-     */
-    fetchLinkedItemEntriesData(parentType: ApiEnumItemType, parentIdArray: ItemId[], itemType: ApiEnumItemType, query: ApiQuery | null, columns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
-    /**
-     * @description
-     * General way to process an API response.
-     * Will call {@link ChangesDelta.setItemCreated setItemCreated} if an entry doesn't exist yet, and otherwise {@link ChangesDelta.setItemUpdated setItemUpdated} if it does.
-     */
-    processApiResponse<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemIdOfExistingItem: ItemId, itemIdInResponse: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>, updateModified?: boolean): void;
-    /**
-     * @description
-     * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.
-     * Will create a new {@link ItemEntry ItemEntry} if the ItemEntry didn't exist yet
-     */
-    private fetchItemEntryData;
-}
+import { ApiEnumItemType, ItemId } from '@rentman/backend-types';
+import { ApiFormatter, ApiQuery, ApiRequestColumns, ApiResponseProcessor, ChangesDelta, ChangesDeltaItemCreateDelta, ChangesDeltaItemUpdateDelta, ColumnExpansion, ColumnSet, ColumnSubsetCacheFactory, ColumnUtil, ErrorHandlerInterface, FieldMap, ItemCacheFactory, ItemEntry, ItemEntryFactory, ItemEntryOptions, ItemHandlerBase, ProcessItemEntryChangesResult, PromiseInterface, PromiseLibraryInterface, QueryParserFactory, QueryService, RequestBufferManager, RequestBufferResponse, RequestColumnExpansionFactory, ServerCache, TransactionItemEntryChanges } from '../../../internal';
+export declare type ServerItemEntryChanges<ItemTypeType extends ApiEnumItemType = any> = FieldMap<ItemTypeType>;
+export declare class ServerItemHandler extends ItemHandlerBase {
+    private requestBufferManager;
+    private queryParserFactory;
+    private queryService;
+    private columnSubsetCacheFactory;
+    protected transaction: ServerCache;
+    itemChanges: {
+        [itemEntryId: number]: ServerItemEntryChanges;
+    };
+    constructor(requestBufferManager: RequestBufferManager, queryParserFactory: QueryParserFactory, queryService: QueryService, columnSubsetCacheFactory: ColumnSubsetCacheFactory, errorHandler: ErrorHandlerInterface, promiseService: PromiseLibraryInterface, columnUtil: ColumnUtil, apiFormatter: ApiFormatter, itemEntryFactory: ItemEntryFactory, itemCacheFactory: ItemCacheFactory, requestColumnExpansionFactory: RequestColumnExpansionFactory, transaction: ServerCache);
+    createItemEntry(createTuple: ChangesDeltaItemCreateDelta): ItemEntry;
+    /**
+     * @description
+     * Processes updates on a cached entry
+     */
+    processItemEntryChanges<ItemTypeType extends ApiEnumItemType = any>(itemEntryChangesTuple: ChangesDeltaItemUpdateDelta<ItemTypeType>, _isCalledAfterSocketUpdate?: boolean, _createItemChangesIfNoneExist?: boolean): ProcessItemEntryChangesResult<ItemTypeType>;
+    copyTransactionItemEntryChanges(itemEntryChanges: TransactionItemEntryChanges, entry: ItemEntry): ServerItemEntryChanges;
+    fetchItemEntry<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemId: ItemId, options: ItemEntryOptions): PromiseInterface<ItemEntry<ItemTypeType>>;
+    fetchItemEntriesByQuery<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, query: ApiQuery, entryOptions: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    extendItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemEntries: Array<ItemEntry<ItemTypeType>>, newColumns: ApiRequestColumns): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    fetchItemEntries<ItemTypeType extends ApiEnumItemType>(itemType: ItemTypeType, itemIds: ItemId[], options: ItemEntryOptions): PromiseInterface<Array<ItemEntry<ItemTypeType>>>;
+    /**
+     * @description
+     * Fetches the data for the ItemEntries linked to the parent Items
+     *
+     * @param columns should contain a derived column that refers to the parent
+     */
+    fetchLinkedItemEntriesData(parentType: ApiEnumItemType, parentIdArray: ItemId[], itemType: ApiEnumItemType, query: ApiQuery | null, columns: ApiRequestColumns): PromiseInterface<RequestBufferResponse>;
+    /**
+     * @description
+     * General way to process an API response.
+     * Will call {@link ChangesDelta.setItemCreated setItemCreated} if an entry doesn't exist yet, and otherwise {@link ChangesDelta.setItemUpdated setItemUpdated} if it does.
+     */
+    processApiResponse<ItemTypeType extends ApiEnumItemType>(changesDelta: ChangesDelta, response: ApiResponseProcessor, itemType: ItemTypeType, itemIdOfExistingItem: ItemId, itemIdInResponse: ItemId, columnSet: ColumnSet<ItemTypeType>, columnExpansion: ColumnExpansion<ItemTypeType>, updateModified?: boolean): void;
+    /**
+     * @description
+     * Fetches the data for the passed ItemType/ItemId/columns, will do nothing if the requested ItemEntry/columns are already cached.
+     * Will create a new {@link ItemEntry ItemEntry} if the ItemEntry didn't exist yet
+     */
+    private fetchItemEntryData;
+}