@astral/mobx-query 1.8.0 → 1.9.0

package/node/Query/Query.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const mobx_1 = require("mobx");
+const AuxiliaryQuery_1 = require("../AuxiliaryQuery");
+const QueryContainer_1 = require("../QueryContainer");
+/**
+ * Стор для работы с запросами,
+ * которые должны быть закешированы,
+ * но им не требуется усложнение в виде работы с фильтрами и инфинити запросами
+ */
+class Query extends QueryContainer_1.QueryContainer {
+    constructor(executor, { onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
+        super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery_1.AuxiliaryQuery(statusStorage, backgroundStatusStorage));
+        this.executor = executor;
+        /**
+         * Метод для инвалидации данных
+         */
+        this.invalidate = () => {
+            this.auxiliary.invalidate();
+        };
+        /**
+         * Синхронный метод получения данных
+         */
+        this.sync = (params) => {
+            const isInstanceAllow = !(this.isLoading || this.isSuccess);
+            if (this.isNetworkOnly || this.auxiliary.isInvalid || isInstanceAllow) {
+                this.proceedSync(params);
+            }
+        };
+        /**
+         * Обработчик успешного ответа
+         */
+        this.submitSuccess = (resData) => {
+            var _a;
+            this.storage.setData(resData);
+            (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
+            return resData;
+        };
+        /**
+         * Форс метод для установки данных
+         */
+        this.forceUpdate = (data) => {
+            this.auxiliary.submitSuccess();
+            this.submitSuccess(data);
+        };
+        /**
+         * Метод для переиспользования синхронной логики запроса
+         */
+        this.proceedSync = (options) => {
+            const { onSuccess, onError } = options || {};
+            this.auxiliary
+                .getUnifiedPromise(this.executor, (res) => {
+                this.submitSuccess(res);
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(res);
+            })
+                .catch((e) => {
+                var _a;
+                if (onError) {
+                    onError(e);
+                }
+                else {
+                    (_a = this.defaultOnError) === null || _a === void 0 ? void 0 : _a.call(this, e);
+                }
+            });
+        };
+        /**
+         * Асинхронный метод получения данных,
+         * предполагается, что нужно будет самостоятельно обрабатывать ошибку
+         */
+        this.async = () => {
+            if (!this.isNetworkOnly && this.isSuccess && !this.auxiliary.isInvalid) {
+                return Promise.resolve(this.storage.data);
+            }
+            return this.auxiliary.getUnifiedPromise(this.executor, this.submitSuccess);
+        };
+        this.defaultOnError = onError;
+        this.enabledAutoFetch = enabledAutoFetch;
+        this.defaultFetchPolicy = fetchPolicy;
+        this.storage = dataStorage;
+        this.submitValidity = submitValidity;
+        (0, mobx_1.makeObservable)(this, {
+            async: mobx_1.action,
+            sync: mobx_1.action,
+            forceUpdate: mobx_1.action,
+            data: mobx_1.computed,
+            submitSuccess: mobx_1.action,
+        });
+    }
+    get isNetworkOnly() {
+        return this.defaultFetchPolicy === 'network-only';
+    }
+    /**
+     * Содержит реактивные данные
+     * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
+     * следовательно, стриггерится условие невалидности,
+     * и начнется запрос, в результате которого, данные обновятся
+     */
+    get data() {
+        const shouldSync = this.enabledAutoFetch &&
+            !this.isSuccess &&
+            !this.isLoading &&
+            !this.isError;
+        if (this.auxiliary.isInvalid || shouldSync) {
+            // т.к. при вызове апдейта, изменяются флаги, на которые подписан data,
+            // нужно вызывать этот экшн асинхронно
+            (0, mobx_1.when)(() => true, this.proceedSync);
+        }
+        // возвращаем имеющиеся данные
+        return this.storage.data;
+    }
+}
+exports.Query = Query;

package/node/Query/index.d.ts

@@ -0,0 +1 @@
+export * from './Query';

package/node/Query/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Query"), exports);

package/node/QueryContainer/QueryContainer.d.ts

@@ -0,0 +1,61 @@
+import { type StatusStorage } from '../StatusStorage';
+export type QueryContainerAuxiliary = {
+    isIdle: boolean;
+};
+type Statuses<TError> = StatusStorage<TError>;
+/**
+ * Контейнер для бойлерплейт части,
+ * позволяет не повторять в каждом наследуемом классе использование стандартных статусов
+ */
+export declare abstract class QueryContainer<TError, TAuxiliary extends QueryContainerAuxiliary, TIsBackground extends boolean> implements Statuses<TError> {
+    private readonly statusStorage;
+    private readonly backgroundStatusStorage;
+    protected readonly auxiliary: TAuxiliary;
+    protected constructor(statusStorage: StatusStorage<TError>, backgroundStatusStorage: StatusStorage<TError> | null, auxiliary: TAuxiliary);
+    /**
+     * Флаг загрузки данных
+     */
+    get isLoading(): boolean;
+    /**
+     * Флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError(): boolean;
+    /**
+     * Данные о последней ошибке
+     */
+    get error(): TError | undefined;
+    /**
+     * Флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess(): boolean;
+    /**
+     * Флаг, обозначающий простаивание, т.е. запроса еще не было
+     */
+    get isIdle(): boolean;
+    /**
+     * Статусы, изменяющиеся после первого успешного запроса в режиме isBackground: true
+     * @example
+     * const query = mobxQuery.createQuery(
+     *     ['some cache key'],
+     *     () => Promise.resolve('foo'),
+     *     { isBackground: true }
+     * );
+     *
+     * await query.async();
+     * console.log(query.isLoading); // переключался в true на момент запроса
+     * console.log(query.isSuccess); // true
+     *
+     * query.invalidate();
+     * await query.async();
+     * console.log(query.isLoading); // не изменялся
+     * console.log(query.isSuccess); // остался неизменным - true
+     *
+     * console.log(query.background.isLoading); // переключался в true на момент обновления
+     * console.log(query.background.isSuccess); // true
+     *
+     * @exception isBackground:false (а так же по умолчанию) background не доступен, и равен null
+     * @exception Mutation не доступен в мутации и равен null
+     */
+    get background(): TIsBackground extends true ? Statuses<TError> : null;
+}
+export {};

package/node/QueryContainer/QueryContainer.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryContainer = void 0;
+const mobx_1 = require("mobx");
+/**
+ * Контейнер для бойлерплейт части,
+ * позволяет не повторять в каждом наследуемом классе использование стандартных статусов
+ */
+class QueryContainer {
+    constructor(statusStorage, backgroundStatusStorage, auxiliary) {
+        this.statusStorage = statusStorage;
+        this.backgroundStatusStorage = backgroundStatusStorage;
+        this.auxiliary = auxiliary;
+        (0, mobx_1.makeObservable)(this, {
+            error: mobx_1.computed,
+            isError: mobx_1.computed,
+            isIdle: mobx_1.computed,
+            isLoading: mobx_1.computed,
+            isSuccess: mobx_1.computed,
+        });
+    }
+    /**
+     * Флаг загрузки данных
+     */
+    get isLoading() {
+        return this.statusStorage.isLoading;
+    }
+    /**
+     * Флаг обозначающий, что последний запрос был зафейлен
+     */
+    get isError() {
+        return this.statusStorage.isError;
+    }
+    /**
+     * Данные о последней ошибке
+     */
+    get error() {
+        return this.statusStorage.error;
+    }
+    /**
+     * Флаг обозначающий, что последний запрос был успешно завершен
+     */
+    get isSuccess() {
+        return this.statusStorage.isSuccess;
+    }
+    /**
+     * Флаг, обозначающий простаивание, т.е. запроса еще не было
+     */
+    get isIdle() {
+        return this.auxiliary.isIdle;
+    }
+    /**
+     * Статусы, изменяющиеся после первого успешного запроса в режиме isBackground: true
+     * @example
+     * const query = mobxQuery.createQuery(
+     *     ['some cache key'],
+     *     () => Promise.resolve('foo'),
+     *     { isBackground: true }
+     * );
+     *
+     * await query.async();
+     * console.log(query.isLoading); // переключался в true на момент запроса
+     * console.log(query.isSuccess); // true
+     *
+     * query.invalidate();
+     * await query.async();
+     * console.log(query.isLoading); // не изменялся
+     * console.log(query.isSuccess); // остался неизменным - true
+     *
+     * console.log(query.background.isLoading); // переключался в true на момент обновления
+     * console.log(query.background.isSuccess); // true
+     *
+     * @exception isBackground:false (а так же по умолчанию) background не доступен, и равен null
+     * @exception Mutation не доступен в мутации и равен null
+     */
+    get background() {
+        if (!this.backgroundStatusStorage) {
+            return null;
+        }
+        return this.backgroundStatusStorage;
+    }
+}
+exports.QueryContainer = QueryContainer;

package/node/QueryContainer/index.d.ts

@@ -0,0 +1 @@
+export * from './QueryContainer';

package/node/QueryContainer/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./QueryContainer"), exports);

package/node/Sets/InfiniteQuerySet/InfiniteQuerySet.d.ts

@@ -0,0 +1,60 @@
+import { type DeepPartial } from 'utility-types';
+import { type CacheKey } from '../../types';
+import { type InfiniteParams, type InfiniteQuery } from '../../InfiniteQuery';
+import { type CreateInfiniteQueryParams, type MobxQuery } from '../../MobxQuery';
+export type InfiniteQuerySetConfig = {
+    name?: string;
+};
+export type InfiniteQuerySetConfigurator<TParams extends any[], TResponse> = (...params: TParams) => {
+    keys?: CacheKey[];
+    execute: (infiniteParams: InfiniteParams) => Promise<TResponse[]>;
+};
+/**
+ * Набор infinite queries под одним ключем с целью повышения читаемости кода и удобства инвалидации по общему ключу
+ */
+export declare class InfiniteQuerySet<TParams extends any[], TResponse, TDefaultError = unknown> {
+    private readonly _cache;
+    private readonly _queryConfigurator;
+    private readonly baseKey;
+    constructor(_cache: MobxQuery, _queryConfigurator: InfiniteQuerySetConfigurator<TParams, TResponse>, config?: InfiniteQuerySetConfig);
+    /**
+     * Создает infinite query в кэше. Добавляет его в набор
+     * @returns InfiniteQuery объект
+     * @example
+     * const docListQuery = docFetcher.infiniteQueries.docList.create()
+     * // Получает данные
+     * docListQuery.sync()
+     */
+    create: <TError = TDefaultError>(...params: TParams) => InfiniteQuery<TResponse, TError>;
+    /**
+     * Создает infinite query в кэше с дополнительными параметрами конфигурации. Добавляет его в набор
+     * @param config - Параметры конфигурации infinite query. Например, fetchPolicy или incrementCount
+     * @param params - Параметры запроса
+     * @returns InfiniteQuery объект
+     * @example
+     * const docListQuery = docFetcher.infiniteQueries.docList.createWithConfig(
+     *   { fetchPolicy: 'network-only', incrementCount: 10 },
+     *   'docId',
+     * )
+     * // Получает данные из query
+     * docListQuery.sync()
+     */
+    createWithConfig: <TError = TDefaultError, TIsBackground extends boolean = false>(config: CreateInfiniteQueryParams<TResponse, TError, TIsBackground>, ...params: TParams) => InfiniteQuery<TResponse, TError, TIsBackground>;
+    /**
+     * Инвалидирует текущий набор infinite queries в кэше
+     * @param params - Параметры функции, переданной в createInfiniteQuerySet при создании набора. Если не указаны, то инвалидируется все query
+     * @example
+     * const docFetcher = {
+     *   infiniteQueries: {
+     *     docList: createInfiniteQuerySet('docList', (search: string) => ({
+     *       execute: ({ count, offset }) => httpService.get(`/doc/${search}?count=${count}&offset=${offset}`),
+     *     }),
+     *   }
+     * };
+     *
+     * // Инвалидирует infinite query с конкретным переданным search
+     * docFetcher.infiniteQueries.docList.invalidate('документ1')
+     */
+    invalidate: (...params: DeepPartial<TParams>) => void;
+    private configureQuery;
+}

package/node/Sets/InfiniteQuerySet/InfiniteQuerySet.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfiniteQuerySet = void 0;
+const utils_1 = require("../utils");
+/**
+ * Набор infinite queries под одним ключем с целью повышения читаемости кода и удобства инвалидации по общему ключу
+ */
+class InfiniteQuerySet {
+    constructor(_cache, _queryConfigurator, config) {
+        var _a;
+        this._cache = _cache;
+        this._queryConfigurator = _queryConfigurator;
+        /**
+         * Создает infinite query в кэше. Добавляет его в набор
+         * @returns InfiniteQuery объект
+         * @example
+         * const docListQuery = docFetcher.infiniteQueries.docList.create()
+         * // Получает данные
+         * docListQuery.sync()
+         */
+        this.create = (...params) => {
+            const { keys, execute } = this.configureQuery(...params);
+            return this._cache.createInfiniteQuery(keys, execute);
+        };
+        /**
+         * Создает infinite query в кэше с дополнительными параметрами конфигурации. Добавляет его в набор
+         * @param config - Параметры конфигурации infinite query. Например, fetchPolicy или incrementCount
+         * @param params - Параметры запроса
+         * @returns InfiniteQuery объект
+         * @example
+         * const docListQuery = docFetcher.infiniteQueries.docList.createWithConfig(
+         *   { fetchPolicy: 'network-only', incrementCount: 10 },
+         *   'docId',
+         * )
+         * // Получает данные из query
+         * docListQuery.sync()
+         */
+        this.createWithConfig = (config, ...params) => {
+            const { keys, execute } = this.configureQuery(...params);
+            return this._cache.createInfiniteQuery(keys, execute, config);
+        };
+        /**
+         * Инвалидирует текущий набор infinite queries в кэше
+         * @param params - Параметры функции, переданной в createInfiniteQuerySet при создании набора. Если не указаны, то инвалидируется все query
+         * @example
+         * const docFetcher = {
+         *   infiniteQueries: {
+         *     docList: createInfiniteQuerySet('docList', (search: string) => ({
+         *       execute: ({ count, offset }) => httpService.get(`/doc/${search}?count=${count}&offset=${offset}`),
+         *     }),
+         *   }
+         * };
+         *
+         * // Инвалидирует infinite query с конкретным переданным search
+         * docFetcher.infiniteQueries.docList.invalidate('документ1')
+         */
+        this.invalidate = (...params) => {
+            if (params.length === 0) {
+                this._cache.invalidate([this.baseKey]);
+                return;
+            }
+            const { keys } = this.configureQuery(...params);
+            this._cache.invalidate(keys, 'chain-match');
+        };
+        this.configureQuery = (...params) => {
+            const { keys, execute } = this._queryConfigurator(...params);
+            return {
+                keys: (0, utils_1.generateQuerySetKeys)(this.baseKey, keys !== null && keys !== void 0 ? keys : params),
+                execute,
+            };
+        };
+        this.baseKey = (_a = config === null || config === void 0 ? void 0 : config.name) !== null && _a !== void 0 ? _a : (0, utils_1.generateQuerySetBaseKey)(_queryConfigurator);
+    }
+}
+exports.InfiniteQuerySet = InfiniteQuerySet;

package/node/Sets/InfiniteQuerySet/index.d.ts

@@ -0,0 +1 @@
+export * from './InfiniteQuerySet';

package/node/Sets/InfiniteQuerySet/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./InfiniteQuerySet"), exports);

package/node/Sets/MutationSet/MutationSet.d.ts

@@ -0,0 +1,32 @@
+import { type MobxQuery } from '../../MobxQuery';
+import { type Mutation, type MutationExecutor } from '../../Mutation';
+/**
+ * Налор мутаций. Цель: единый интерфейс создания и использования наборов Query и Mutation
+ * @example
+ * const docFetcher = {
+ *   mutations: {
+ *     editDoc: mobxQuery.createMutationSet((params: DocsEndpointsDTO.EditDocInput) => {
+ *       return docsEndpoint.editDoc(params);
+ *     }),
+ *   },
+ *  queries: {
+ *     doc: mobxQuery.createQuerySet((id: string) => ({
+ *       execute: () => docsEndpoint.getDoc(id).then(({ data }) => data),
+ *     })),
+ *   },
+ * }
+ */
+export declare class MutationSet<TResponse, TParams = void, TDefaultError = unknown> {
+    private readonly _cache;
+    private readonly _executor;
+    constructor(_cache: MobxQuery, _executor: MutationExecutor<TResponse, TParams>);
+    /**
+     * Создает мутацию
+     * @returns Mutation объект
+     * @example
+     * const editDocMutation = docFetcher.mutations.editDoc.create();
+     * // Выполняет мутацию
+     * editDocMutation.sync({ params: { id: 'docId', content: 'Новое содержимое' } });
+     */
+    create: <TError = TDefaultError>() => Mutation<TResponse, TError, TParams>;
+}

package/node/Sets/MutationSet/MutationSet.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutationSet = void 0;
+/**
+ * Налор мутаций. Цель: единый интерфейс создания и использования наборов Query и Mutation
+ * @example
+ * const docFetcher = {
+ *   mutations: {
+ *     editDoc: mobxQuery.createMutationSet((params: DocsEndpointsDTO.EditDocInput) => {
+ *       return docsEndpoint.editDoc(params);
+ *     }),
+ *   },
+ *  queries: {
+ *     doc: mobxQuery.createQuerySet((id: string) => ({
+ *       execute: () => docsEndpoint.getDoc(id).then(({ data }) => data),
+ *     })),
+ *   },
+ * }
+ */
+class MutationSet {
+    constructor(_cache, _executor) {
+        this._cache = _cache;
+        this._executor = _executor;
+        /**
+         * Создает мутацию
+         * @returns Mutation объект
+         * @example
+         * const editDocMutation = docFetcher.mutations.editDoc.create();
+         * // Выполняет мутацию
+         * editDocMutation.sync({ params: { id: 'docId', content: 'Новое содержимое' } });
+         */
+        this.create = () => this._cache.createMutation(this._executor);
+    }
+}
+exports.MutationSet = MutationSet;

package/node/Sets/MutationSet/index.d.ts

@@ -0,0 +1 @@
+export * from './MutationSet';

package/node/Sets/MutationSet/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MutationSet"), exports);

package/node/Sets/QuerySet/QuerySet.d.ts

@@ -0,0 +1,64 @@
+import { type DeepPartial } from 'utility-types';
+import { type CacheKey } from '../../types';
+import { type Query } from '../../Query';
+import { type CreateQueryParams, type MobxQuery } from '../../MobxQuery';
+export type QuerySetConfig = {
+    name?: string;
+};
+export type QuerySetConfigurator<TParams extends any[], TResponse> = (...params: TParams) => {
+    keys?: CacheKey[];
+    execute: () => Promise<TResponse>;
+};
+/**
+ * Набор queries под одним ключем с целью повышения читаемости кода и удобства инвалидации по общему ключу
+ */
+export declare class QuerySet<TParams extends any[], TResponse, TDefaultError = unknown> {
+    private readonly _cache;
+    private readonly _queryConfigurator;
+    /**
+     * Хэш от queryConfigurator
+     */
+    private readonly baseKey;
+    constructor(_cache: MobxQuery, _queryConfigurator: QuerySetConfigurator<TParams, TResponse>, config?: QuerySetConfig);
+    /**
+     * Создает query в кэше. Добавляет его в набор
+     * @returns Query объект
+     * @example
+     * const docQuery = docFetcher.queries.doc.create('docId')
+     * // Получает данные
+     * docQuery.sync()
+     */
+    create: <TError = TDefaultError>(...params: TParams) => Query<TResponse, TError>;
+    /**
+     * Создает query в кэше с дополнительными параметрами конфигурации. Добавляет его в набор
+     * @param config - Параметры конфигурации query. Например, fetchPolicy
+     * @param params - Параметры запроса
+     * @returns Query объект
+     * @example
+     * const docQuery = docFetcher.queries.doc.createWithConfig(
+     *   { fetchPolicy: 'network-only' },
+     *   'docId',
+     * )
+     * // Получает данные из query
+     * docQuery.sync()
+     */
+    createWithConfig: <TError = TDefaultError, TIsBackground extends boolean = false>(config: CreateQueryParams<Awaited<TResponse>, TError, TIsBackground>, ...params: TParams) => Query<TResponse, TError, TIsBackground>;
+    /**
+     * Инвалидирует текущий query в кэше
+     * @param keys - Дополнительные ключи для инвалидации. Если не указаны, то инвалидируется весь набор query
+     * @example
+     * const docFetcher = {
+     *   doc: mobxQuery.createQuerySet((id: string) => ({
+     *     execute: () => httpService.get(`/doc/${id}?page=${page}`),
+     *   })),
+     * };
+     *
+     * // Инвалидирует все query doc
+     * docFetcher.doc.invalidate()
+     *
+     * // Инвалидирует query doc с конкретным переданным id. Доступные ключи инвалидации зависят от указанных additionalKeys, переданных при определении query в фабрике createDataFetcher
+     * docFetcher.doc.invalidate('docId')
+     */
+    invalidate: (...params: DeepPartial<TParams>) => void;
+    private configureQuery;
+}