@fozy-labs/rx-toolkit 0.5.3-rc.1 → 0.5.3

package/dist/query/types/Operation.types.d.ts

@@ -1,154 +1,13 @@
-import { ReadableSignalLike } from "../../signals/types";
-import { FallbackOnNever, OnCacheEntryAdded, OnQueryStarted } from "./shared.types";
-import { ResourceDefinition, ResourceInstance } from "./Resource.types";
-/**
- * Функция создания операции
- */
-export type OperationCreateFn<ARGS, RESULT, SELECTED = never> = (options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => OperationInstance<OperationDefinition<ARGS, RESULT, SELECTED>>;
-/**
- * Опции создания операции
- */
-export type OperationCreateOptions<D extends OperationDefinition> = {
-    /** Функция селектора для преобразования результата операции */
-    select?: (data: D["Result"]) => D["Selected"];
-    /** Функция выполнения операции */
-    queryFn: (args: D["Args"]) => Promise<D["Result"]>;
-    /** Связанные ресурсы */
-    link?: (link: <RD extends ResourceDefinition>(options: LinkOptions<D, RD>) => void) => void;
-    /**
-     * Время жизни кеша в миллисекундах. По умолчанию 1_000 (1 секунда).
-     * Если указано false - кеш не удаляется автоматически.
-     */
-    cacheLifetime?: number | false;
-    /**
-     * Хук, вызываемый при добавлении нового элемента в кеш.
-     * Также позволяет отследить:
-     *  - когда данные были загружены (впервые)
-     *  - когда элемент был удален из кеша
-     */
-    onCacheEntryAdded?: OnCacheEntryAdded<D["Args"], D["Data"]>;
-    /**
-     * Хук, вызываемый при старте запроса.
-     * Также позволяет отследить:
-     * - завершение запроса с результатом или ошибкой
-     */
-    onQueryStarted?: OnQueryStarted<D["Args"], D["Result"]>;
-    /**
-     * Настройка отображения в devtools
-     */
-    devtoolsName?: string | false;
-};
-/**
- * Настройки связи операции с ресурсом
- */
-export type LinkOptions<D extends OperationDefinition, RD extends ResourceDefinition> = {
-    /**
-     * Целевой ресурс, с которым связывается операция
-     * @required
-     */
-    resource: ResourceInstance<RD>;
-    /**
-     * Функция для получения аргументов ресурса из аргументов операции.
-     * Используется для определения какой именно элемент в кэше ресурса нужно обновить
-     * @required
-     */
-    forwardArgs: (args: D["Args"]) => RD["Args"];
-    /**
-     * Флаг для инвалидации (очистки) кэша ресурса после выполнения операции.
-     * При true - кэш будет очищен и ресурс будет перезагружен при следующем обращении
-     * @optional @default false
-     */
-    invalidate?: boolean;
-    /**
-     * Флаг для блокировки ресурса во время выполнения операции.
-     * При true - ресурс будет заблокирован и не сможет выполнять новые запросы
-     * @optional @default false
-     */
-    lock?: boolean;
-    /**
-     * Функция для обновления кэша ресурса после успешного выполнения операции.
-     * Получает draft объект для мутации, аргументы операции и результат операции
-     * @optional
-     */
-    update?: (tools: {
-        /** Immer draft объект для мутации кэша ресурса */
-        draft: RD["Data"];
-        /** Аргументы, с которыми была вызвана операция */
-        args: D["Args"];
-        /** Результат выполнения операции */
-        data: D["Data"];
-    }) => void | RD["Data"] | Promise<RD["Data"]>;
-    /**
-     * Функция для оптимистичного обновления кэша ресурса ДО выполнения операции.
-     * Позволяет обновить UI немедленно, до получения ответа от сервера
-     * @optional
-     */
-    optimisticUpdate?: (tools: {
-        /** Immer draft объект для мутации кэша ресурса */
-        draft: RD["Data"];
-        /** Аргументы, с которыми была вызвана операция */
-        args: D["Args"];
-    }) => void | RD["Data"] | Promise<RD["Data"]>;
-    /**
-     * Функция для создания нового элемента в кэше ресурса.
-     * Используется когда операция создает новую сущность, которую нужно добавить в кэш
-     * @optional
-     */
-    create?: (tools: {
-        /** Аргументы, с которыми была вызвана операция */
-        args: D["Args"];
-        /** Результат выполнения операции */
-        data: D["Data"];
-    }) => RD["Data"] | Promise<RD["Data"]>;
-};
-/**
- * Определение типов операции
- */
-export type OperationDefinition<A = any, R = any, S = any> = {
-    Args: A;
-    Result: R;
-    Selected: S;
-    Data: FallbackOnNever<S, R>;
-};
-/**
- * Экземпляр операции
- */
-export type OperationInstance<D extends OperationDefinition> = {
-    /** Создает агента для выполнения операции */
-    createAgent(): OperationAgentInstanse<D>;
-    /**
-     * Выполняет операцию с указанными аргументами
-     * @deprecated
-     */
-    mutate: (args: D["Args"]) => Promise<D["Data"]>;
-};
-/**
- * Агент для выполнения операции
- */
-export type OperationAgentInstanse<D extends OperationDefinition> = {
-    /** Observable состояния выполнения операции */
-    state$: ReadableSignalLike<OperationQueryState<D>>;
-    /** Инициирует выполнение операции с указанными аргументами */
-    initiate(args: D["Args"]): void;
-    /** Создает новый агент операции */
-    createAgent(): OperationAgentInstanse<D>;
-};
-/**
- * Состояние выполнения операции
- */
-export type OperationQueryState<D extends OperationDefinition> = {
-    /** Выполняется ли операция в данный момент */
-    isLoading: boolean;
-    /** Завершена ли операция */
-    isDone: boolean;
-    /** Успешно ли завершена операция (false по умолчанию) */
-    isSuccess: boolean;
-    /** Произошла ли ошибка при выполнении операции (false по умолчанию) */
-    isError: boolean;
-    /** Оригинал ошибки, если есть */
-    error: unknown | undefined;
-    /** Результат выполнения операции */
-    data: D["Data"] | undefined;
-    /** Аргументы операции */
-    args: D["Args"];
-};
+import { CommandAgentInstance, CommandCreateFn, CommandCreateOptions, CommandDefinition, CommandInstance, CommandQueryState } from "./Command.types";
+/** @deprecated Use `CommandCreateFn` instead. Will be removed in v0.6.0. */
+export type OperationCreateFn<ARGS, RESULT, SELECTED = never> = CommandCreateFn<ARGS, RESULT, SELECTED>;
+/** @deprecated Use `CommandCreateOptions` instead. Will be removed in v0.6.0. */
+export type OperationCreateOptions<D extends CommandDefinition> = CommandCreateOptions<D>;
+/** @deprecated Use `CommandDefinition` instead. Will be removed in v0.6.0. */
+export type OperationDefinition<A = any, R = any, S = any> = CommandDefinition<A, R, S>;
+/** @deprecated Use `CommandInstance` instead. Will be removed in v0.6.0. */
+export type OperationInstance<D extends CommandDefinition> = CommandInstance<D>;
+/** @deprecated Use `CommandAgentInstance` instead. Will be removed in v0.6.0. */
+export type OperationAgentInstanse<D extends CommandDefinition> = CommandAgentInstance<D>;
+/** @deprecated Use `CommandQueryState` instead. Will be removed in v0.6.0. */
+export type OperationQueryState<D extends CommandDefinition> = CommandQueryState<D>;

package/dist/query/types/Resource.types.d.ts

@@ -61,7 +61,7 @@ export type ResourceInstance<D extends ResourceDefinition> = {
     /** Создает агента для работы с ресурсом */
     createAgent(): ResourceAgentInstance<D>;
     /** Создает ссылку на ресурс с указанными аргументами */
-    createRef(args: D["Args"]): ResourceRefInstanse<D>;
+    createRef(args: D["Args"]): ResourceRefInstance<D>;
 };
 /**
  * Агент для работы с ресурсом
@@ -107,7 +107,7 @@ export type ResourceQueryState<D extends ResourceDefinition> = {
 export type ResourceTransaction = {
     patches: ImmerPatch[];
     inversePatches: ImmerPatch[];
-    status: 'pending' | 'committed' | 'aborted';
+    status: "pending" | "committed" | "aborted";
     abort(): void;
     commit(): void;
 };
@@ -115,13 +115,15 @@ export type ResourceTransaction = {
  * Эте не ссылка в "классическом" понимании, а абстракция
  * для работы с элементом кеша ресурса.
  */
-export type ResourceRefInstanse<D extends ResourceDefinition> = {
+export type ResourceRefInstance<D extends ResourceDefinition> = {
     get has(): boolean;
     lock(): {
         unlock: () => void;
     };
     unlockOne(): void;
-    patch(patchFn: (data: D['Data']) => void): ResourceTransaction | null;
+    patch(patchFn: (data: D["Data"]) => void): ResourceTransaction | null;
     invalidate(): void;
-    create(data: D['Data']): void;
+    create(data: D["Data"]): void;
 };
+/** @deprecated Use ResourceRefInstance. Will be removed in v0.6.0 */
+export type ResourceRefInstanse<D extends ResourceDefinition> = ResourceRefInstance<D>;

package/dist/query/types/index.d.ts

@@ -1,3 +1,4 @@
-export * from './Operation.types';
-export * from './Resource.types';
-export * from './shared.types';
+export * from "./Command.types";
+export * from "./Resource.types";
+export * from "./shared.types";
+export * from "./Operation.types";

package/dist/query/types/index.js

@@ -1,3 +1,5 @@
-export * from './Operation.types';
-export * from './Resource.types';
-export * from './shared.types';
+export * from "./Command.types";
+export * from "./Resource.types";
+export * from "./shared.types";
+// Deprecated Operation types (backward compatibility)
+export * from "./Operation.types";

package/dist/query-v2/api/createApi.d.ts

@@ -0,0 +1,10 @@
+import type { IApi, ICreateApiOptions } from "../../query-v2/types/api.types";
+import type { IPlugin } from "../../query-v2/types/plugin.types";
+/**
+ * Create a query-v2 API instance — the root entry point for managing resources, snapshots, and plugins.
+ *
+ * @param options - Configuration for the API instance (keyPrefix, plugins, snapshot, cache settings).
+ * @returns API instance with `createResource`, `resetAll`, and `getSnapshot` methods.
+ * @see docs/query-v2/README.md
+ */
+export declare function createApi<TPlugins extends IPlugin[] = []>(options?: ICreateApiOptions<TPlugins>): IApi<TPlugins>;

package/dist/query-v2/api/createApi.js

@@ -0,0 +1,83 @@
+import { ResourceV2 } from "../../query-v2/core/resource/ResourceV2";
+import { getSnapshot, hydrateSnapshot } from "../../query-v2/snapshot/Snapshot";
+const DEFAULT_CACHE_LIFETIME = 60_000;
+const DEFAULT_MAX_SNAPSHOT_DATA_AGE = 300_000; // 5 minutes
+/**
+ * Create a query-v2 API instance — the root entry point for managing resources, snapshots, and plugins.
+ *
+ * @param options - Configuration for the API instance (keyPrefix, plugins, snapshot, cache settings).
+ * @returns API instance with `createResource`, `resetAll`, and `getSnapshot` methods.
+ * @see docs/query-v2/README.md
+ */
+export function createApi(options = {}) {
+    const { keyPrefix = null, keyStrategy = "serialize", serializeArgs, compareArg, initialSnapshot = null, cacheLifetime = DEFAULT_CACHE_LIFETIME, plugins = [], maxSnapshotDataAge = DEFAULT_MAX_SNAPSHOT_DATA_AGE, doCacheArgs = false, } = options;
+    // ADR-6: Generic registry (Map, not typed to resources only)
+    const registry = new Map();
+    // Plugin initialization: call install() once per plugin
+    const pluginContext = {
+        get api() {
+            return api;
+        },
+        keyStrategy,
+    };
+    for (const plugin of plugins) {
+        plugin.install(pluginContext);
+    }
+    const api = {
+        createResource(resourceOptions) {
+            // Merge: resource options override API defaults
+            const mergedConfig = {
+                key: resourceOptions.key,
+                keyPrefix: keyPrefix ?? undefined,
+                keyStrategy,
+                queryFn: resourceOptions.queryFn,
+                onCacheEntryAdded: resourceOptions.onCacheEntryAdded,
+                onQueryStarted: resourceOptions.onQueryStarted,
+                serializeArgs: resourceOptions.serializeArgs ?? serializeArgs,
+                compareArg: resourceOptions.compareArg ?? compareArg,
+                cacheLifetime: resourceOptions.cacheLifetime ?? cacheLifetime,
+                beforeDevtoolsPush: resourceOptions.beforeDevtoolsPush,
+                maxSnapshotDataAge: resourceOptions.maxSnapshotDataAge ?? maxSnapshotDataAge,
+                doCacheArgs: resourceOptions.doCacheArgs ?? doCacheArgs,
+            };
+            // Validate unique key (for serialize strategy, key is expected for snapshot)
+            const resourceKey = mergedConfig.key;
+            if (resourceKey != null) {
+                if (registry.has(resourceKey)) {
+                    throw new Error(`Duplicate resource key "${resourceKey}". Each resource must have a unique key.`);
+                }
+            }
+            // Create resource
+            const resource = new ResourceV2(mergedConfig);
+            // Apply plugin augmentations
+            const augmentations = {};
+            for (const plugin of plugins) {
+                const pluginContributions = plugin.augmentResource(resource, resourceOptions);
+                Object.assign(augmentations, pluginContributions);
+            }
+            // Create the augmented resource
+            const augmentedResource = Object.assign(resource, augmentations);
+            // Register resource
+            if (resourceKey != null) {
+                registry.set(resourceKey, resource);
+            }
+            // Hydrate from initial snapshot if available
+            if (initialSnapshot && resourceKey != null) {
+                const snapshotMaxAge = mergedConfig.maxSnapshotDataAge ?? maxSnapshotDataAge;
+                const singleResourceRegistry = new Map();
+                singleResourceRegistry.set(resourceKey, resource);
+                hydrateSnapshot(initialSnapshot, singleResourceRegistry, keyPrefix, snapshotMaxAge);
+            }
+            return augmentedResource;
+        },
+        resetAll() {
+            for (const [, resource] of registry) {
+                resource.resetCache();
+            }
+        },
+        getSnapshot() {
+            return getSnapshot(registry, keyPrefix, keyStrategy);
+        },
+    };
+    return api;
+}

package/dist/query-v2/core/common/CacheEntry.d.ts

@@ -0,0 +1,29 @@
+import type { TBeforeDevtoolsPushFn } from "../../../query-v2/types/shared.types";
+import type { TMachineInstance } from "../machines/Machine";
+export interface CacheEntryOptions {
+    keyParts?: string[];
+    beforeDevtoolsPush?: TBeforeDevtoolsPushFn<unknown>;
+}
+/**
+ * Cache entry wrapping a reactive signal over a state machine instance.
+ * Represents a single cached query result with its full lifecycle (idle → pending → success/error).
+ */
+export declare class CacheEntry<TData = unknown, TError = Error> {
+    private readonly _signal;
+    private readonly _onClean$;
+    private _completed;
+    constructor(initialMachine: TMachineInstance<TData, TError>, options?: CacheEntryOptions);
+    /** Reactive accessor for the current machine state — reading this registers a signal dependency. */
+    get machine$(): () => TMachineInstance<TData, TError>;
+    /** Non-reactive read of the current machine state (does not register a signal dependency). */
+    peek(): TMachineInstance<TData, TError>;
+    /** Transition to a new machine state. No-op if the entry has been completed. */
+    set(machine: TMachineInstance<TData, TError>): void;
+    get onClean$(): {
+        subscribe: (cb: () => void) => {
+            unsubscribe: () => void;
+        };
+    };
+    /** Complete the entry — aborts pending patches, resets to idle, and notifies cleanup listeners. */
+    complete(): void;
+}

package/dist/query-v2/core/common/CacheEntry.js

@@ -0,0 +1,71 @@
+import { Subject } from "rxjs";
+import { Signal } from "../../../signals";
+import { MachineIdle } from "../machines/MachineIdle";
+import { MachineWithData } from "../machines/MachineWithData";
+/**
+ * Cache entry wrapping a reactive signal over a state machine instance.
+ * Represents a single cached query result with its full lifecycle (idle → pending → success/error).
+ */
+export class CacheEntry {
+    _signal;
+    _onClean$ = new Subject();
+    _completed = false;
+    constructor(initialMachine, options) {
+        const userCallback = options?.beforeDevtoolsPush;
+        // Default beforeDevtoolsPush projects machine → machine.state for devtools (ADR-8).
+        // The push function types are mismatched intentionally: we push plain state objects
+        // instead of machine instances to keep devtools output JSON-friendly.
+        const beforeDevtoolsPush = ((newValue, push) => {
+            const machine = newValue;
+            const state = machine.state;
+            if (userCallback) {
+                userCallback(state, push);
+            }
+            else {
+                push(state);
+            }
+        });
+        this._signal = Signal.state(initialMachine, {
+            key: options?.keyParts?.join("/"),
+            beforeDevtoolsPush,
+        });
+    }
+    /** Reactive accessor for the current machine state — reading this registers a signal dependency. */
+    get machine$() {
+        return this._signal;
+    }
+    /** Non-reactive read of the current machine state (does not register a signal dependency). */
+    peek() {
+        return this._signal.peek();
+    }
+    /** Transition to a new machine state. No-op if the entry has been completed. */
+    set(machine) {
+        if (this._completed)
+            return;
+        this._signal.set(machine);
+    }
+    get onClean$() {
+        return {
+            subscribe: (cb) => {
+                const sub = this._onClean$.subscribe(cb);
+                return { unsubscribe: () => sub.unsubscribe() };
+            },
+        };
+    }
+    /** Complete the entry — aborts pending patches, resets to idle, and notifies cleanup listeners. */
+    complete() {
+        if (this._completed)
+            return;
+        this._completed = true;
+        // Layer 3 (ADR-4): Abort all pending patches on MachineWithData instances
+        const current = this._signal.peek();
+        if (current instanceof MachineWithData) {
+            current.abortAllPendingPatches();
+        }
+        // Set to idle to release data references
+        this._signal.set(MachineIdle.create());
+        // Notify cleanup listeners
+        this._onClean$.next();
+        this._onClean$.complete();
+    }
+}

package/dist/query-v2/core/common/CacheMap.d.ts

@@ -0,0 +1,38 @@
+import type { ICacheMapOptions } from "../../../query-v2/types/cache.types";
+import type { CacheEntry } from "./CacheEntry";
+declare class SerializedCacheMap<TArgs, TData, TError = Error> {
+    private readonly _map;
+    private readonly _serializeArgs;
+    private readonly _argsMemo;
+    constructor(serializeArgs: (args: unknown) => string, doCacheArgs: boolean);
+    private _serialize;
+    get(args: TArgs): CacheEntry<TData, TError> | undefined;
+    set(args: TArgs, entry: CacheEntry<TData, TError>): void;
+    getOrCreate(args: TArgs, factory: () => CacheEntry<TData, TError>): CacheEntry<TData, TError>;
+    delete(args: TArgs): boolean;
+    has(args: TArgs): boolean;
+    values(): Iterable<CacheEntry<TData, TError>>;
+    entries(): Iterable<[string, CacheEntry<TData, TError>]>;
+    clear(): void;
+    get size(): number;
+}
+declare class CompareCacheMap<TArgs, TData, TError = Error> {
+    private readonly _items;
+    private readonly _compareArg;
+    constructor(compareArg: (a: unknown, b: unknown) => boolean);
+    private _findIndex;
+    get(args: TArgs): CacheEntry<TData, TError> | undefined;
+    set(args: TArgs, entry: CacheEntry<TData, TError>): void;
+    getOrCreate(args: TArgs, factory: () => CacheEntry<TData, TError>): CacheEntry<TData, TError>;
+    delete(args: TArgs): boolean;
+    has(args: TArgs): boolean;
+    values(): Iterable<CacheEntry<TData, TError>>;
+    entries(): Iterable<[TArgs, CacheEntry<TData, TError>]>;
+    clear(): void;
+    get size(): number;
+}
+export type TCacheMapInstance<TArgs, TData, TError = Error> = SerializedCacheMap<TArgs, TData, TError> | CompareCacheMap<TArgs, TData, TError>;
+export declare const CacheMap: {
+    create<TArgs, TData, TError = Error>(options: ICacheMapOptions<TArgs>): TCacheMapInstance<TArgs, TData, TError>;
+};
+export {};

package/dist/query-v2/core/common/CacheMap.js

@@ -0,0 +1,127 @@
+import { shallowEqual } from "../../../common/utils/shallowEqual";
+import { stableStringify } from "../../../query-v2/lib/stableStringify";
+class SerializedCacheMap {
+    _map = new Map();
+    _serializeArgs;
+    _argsMemo;
+    constructor(serializeArgs, doCacheArgs) {
+        this._serializeArgs = serializeArgs;
+        this._argsMemo = doCacheArgs ? new WeakMap() : null;
+    }
+    _serialize(args) {
+        if (this._argsMemo && typeof args === "object" && args !== null) {
+            let cached = this._argsMemo.get(args);
+            if (cached === undefined) {
+                cached = this._serializeArgs(args);
+                this._argsMemo.set(args, cached);
+            }
+            return cached;
+        }
+        return this._serializeArgs(args);
+    }
+    get(args) {
+        return this._map.get(this._serialize(args));
+    }
+    set(args, entry) {
+        this._map.set(this._serialize(args), entry);
+    }
+    getOrCreate(args, factory) {
+        const key = this._serialize(args);
+        let entry = this._map.get(key);
+        if (!entry) {
+            entry = factory();
+            this._map.set(key, entry);
+        }
+        return entry;
+    }
+    delete(args) {
+        return this._map.delete(this._serialize(args));
+    }
+    has(args) {
+        return this._map.has(this._serialize(args));
+    }
+    values() {
+        return this._map.values();
+    }
+    entries() {
+        return this._map.entries();
+    }
+    clear() {
+        this._map.clear();
+    }
+    get size() {
+        return this._map.size;
+    }
+}
+class CompareCacheMap {
+    _items = [];
+    _compareArg;
+    constructor(compareArg) {
+        this._compareArg = compareArg;
+    }
+    _findIndex(args) {
+        for (let i = 0; i < this._items.length; i++) {
+            if (this._compareArg(this._items[i].args, args)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    get(args) {
+        const idx = this._findIndex(args);
+        return idx >= 0 ? this._items[idx].entry : undefined;
+    }
+    set(args, entry) {
+        const idx = this._findIndex(args);
+        if (idx >= 0) {
+            this._items[idx] = { args, entry };
+        }
+        else {
+            this._items.push({ args, entry });
+        }
+    }
+    getOrCreate(args, factory) {
+        const idx = this._findIndex(args);
+        if (idx >= 0) {
+            return this._items[idx].entry;
+        }
+        const entry = factory();
+        this._items.push({ args, entry });
+        return entry;
+    }
+    delete(args) {
+        const idx = this._findIndex(args);
+        if (idx >= 0) {
+            this._items.splice(idx, 1);
+            return true;
+        }
+        return false;
+    }
+    has(args) {
+        return this._findIndex(args) >= 0;
+    }
+    *values() {
+        for (const item of this._items) {
+            yield item.entry;
+        }
+    }
+    *entries() {
+        for (const item of this._items) {
+            yield [item.args, item.entry];
+        }
+    }
+    clear() {
+        this._items.length = 0;
+    }
+    get size() {
+        return this._items.length;
+    }
+}
+export const CacheMap = {
+    create(options) {
+        if (options.keyStrategy === "compare") {
+            return new CompareCacheMap(options.compareArg ?? shallowEqual);
+        }
+        return new SerializedCacheMap(options.serializeArgs ?? stableStringify, options.doCacheArgs);
+    },
+};

package/dist/query-v2/core/common/LifecycleHooks.d.ts

@@ -0,0 +1,22 @@
+import type { TOnCacheEntryAdded, TOnQueryStarted } from "../../../query-v2/types/lifecycle.types";
+import type { TMachineInstance } from "../machines/Machine";
+import type { CacheEntry } from "./CacheEntry";
+export declare class LifecycleHooks<TArgs, TData, TError = Error> {
+    private readonly _onCacheEntryAdded?;
+    private readonly _onQueryStarted?;
+    private _cacheEntryState;
+    private _queryState;
+    private _serializeArgs;
+    constructor(options: {
+        onCacheEntryAdded?: TOnCacheEntryAdded<TArgs, TData>;
+        onQueryStarted?: TOnQueryStarted<TArgs, TData>;
+        serializeArgs: (args: unknown) => string;
+    });
+    fireCacheEntryAdded(args: TArgs, getCacheEntry: () => TMachineInstance<TData, TError>): void;
+    fireCacheEntryRemoved(args: TArgs): void;
+    resolveCacheDataLoaded(args: TArgs, data: TData): void;
+    fireQueryStarted(args: TArgs, getCacheEntry: () => CacheEntry<TData, TError>): void;
+    resolveQueryFulfilled(data: TData): void;
+    rejectQueryFulfilled(error: unknown): void;
+    clearAll(): void;
+}