@astral/mobx-query 1.4.0 → 1.6.0

package/InfiniteQuery/InfiniteQuery.js

@@ -1,40 +1,36 @@
-import { makeAutoObservable, when } from 'mobx';
+import { action, computed, makeObservable, when } from 'mobx';
 import { AuxiliaryQuery } from '../AuxiliaryQuery';
+import { QueryContainer } from '../QueryContainer';
 export const DEFAULT_INFINITE_ITEMS_COUNT = 30;
 /**
- * @description стор для работы с инфинити запросами,
+ * Квери для работы с инфинити запросами,
  * которые должны быть закешированы,
  */
-export class InfiniteQuery {
-    constructor(executor, { incrementCount = DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, }) {
-        /**
-         * @description инстанс вспомогательного стора
-         */
-        this.auxiliary = new AuxiliaryQuery();
+export class InfiniteQuery extends QueryContainer {
+    constructor(executor, { incrementCount = DEFAULT_INFINITE_ITEMS_COUNT, onError, enabledAutoFetch, fetchPolicy, dataStorage, statusStorage, backgroundStatusStorage = null, submitValidity, }) {
+        super(statusStorage, backgroundStatusStorage, new AuxiliaryQuery(statusStorage, backgroundStatusStorage));
+        this.executor = executor;
         /**
-         * @description счетчик отступа для инфинити запроса
+         * Счетчик отступа для инфинити запроса
          */
         this.offset = 0;
         /**
-         * @description флаг того, что мы достигли предела запрашиваемых элементов
+         * Флаг того, что мы достигли предела запрашиваемых элементов
          */
         this.isEndReached = false;
         /**
-         * @description флаг необходимости выполнить обновления данных
-         */
-        this.isInvalid = false;
-        /**
-         * @description обработчик успешного запроса, проверяет что мы достигли предела
+         * Обработчик успешного запроса, проверяет что мы достигли предела
          */
         this.submitSuccess = (result, onSuccess, isIncrement) => {
+            var _a;
             onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(result);
             if (isIncrement && this.storage.hasData) {
                 this.storage.setData([...this.storage.data, ...result]);
             }
             else {
                 this.storage.setData(result);
+                (_a = this.submitValidity) === null || _a === void 0 ? void 0 : _a.call(this);
             }
-            this.isInvalid = false;
             // убеждаемся что результат запроса действительно массив,
             // и если количество элементов в ответе меньше,
             // чем запрашивалось, значит у бэка их больше нет,
@@ -47,7 +43,7 @@ export class InfiniteQuery {
             }
         };
         /**
-         * @description форс метод для установки данных
+         * Форс метод для установки данных
          */
         this.forceUpdate = (data) => {
             this.offset = 0;
@@ -56,13 +52,13 @@ export class InfiniteQuery {
             this.submitSuccess(data);
         };
         /**
-         * @description метод для инвалидации данных
+         * Метод для инвалидации данных
          */
         this.invalidate = () => {
-            this.isInvalid = true;
+            this.auxiliary.invalidate();
         };
         /**
-         * @description метод для запроса следующего набора данных
+         * Метод для запроса следующего набора данных
          */
         this.fetchMore = () => {
             // если мы еще не достигли предела
@@ -78,16 +74,16 @@ export class InfiniteQuery {
             }
         };
         /**
-         * @description синхронный метод получения данных
+         * Синхронный метод получения данных
          */
         this.sync = (params) => {
             const isInstanceAllow = !(this.isLoading || this.isSuccess);
-            if (this.isNetworkOnly || this.isInvalid || isInstanceAllow) {
+            if (this.isNetworkOnly || this.auxiliary.isInvalid || isInstanceAllow) {
                 this.proceedSync(params);
             }
         };
         /**
-         * @description метод для переиспользования синхронной логики запроса
+         * Метод для переиспользования синхронной логики запроса
          */
         this.proceedSync = ({ onSuccess, onError, } = {}) => {
             this.offset = 0;
@@ -108,13 +104,13 @@ export class InfiniteQuery {
             });
         };
         /**
-         * @description aсинхронный метод получения данных,
+         * Асинхронный метод получения данных,
          * подходит для изменения параметров запроса(фильтров),
          * при котором будет сброшен offset,
          * предполагается, что нужно будет самостоятельно обрабатывать ошибку
          */
         this.async = () => {
-            if (!this.isNetworkOnly && this.isSuccess && !this.isInvalid) {
+            if (!this.isNetworkOnly && this.isSuccess && !this.auxiliary.isInvalid) {
                 return Promise.resolve(this.storage.data);
             }
             this.offset = 0;
@@ -132,17 +128,25 @@ export class InfiniteQuery {
         };
         this.storage = dataStorage;
         this.incrementCount = incrementCount;
-        this.executor = executor;
         this.defaultOnError = onError;
         this.enabledAutoFetch = enabledAutoFetch;
         this.defaultFetchPolicy = fetchPolicy;
-        makeAutoObservable(this);
+        this.submitValidity = submitValidity;
+        makeObservable(this, {
+            data: computed,
+            infiniteExecutor: computed,
+            forceUpdate: action,
+            async: action,
+            sync: action,
+            fetchMore: action,
+            submitSuccess: action,
+        });
     }
     get isNetworkOnly() {
         return this.defaultFetchPolicy === 'network-only';
     }
     /**
-     * @description метод для обогащения параметров текущими значениями для инфинити
+     * Метод для обогащения параметров текущими значениями для инфинити
      */
     get infiniteExecutor() {
         return () => this.executor({
@@ -151,7 +155,7 @@ export class InfiniteQuery {
         });
     }
     /**
-     * @description вычисляемое свойство, содержащее реактивные данные,
+     * Вычисляемое свойство, содержащее реактивные данные,
      * благодаря mobx, при изменении isInvalid, свойство будет вычисляться заново,
      * следовательно, стриггерится условие невалидности,
      * и начнется запрос, в результате которого, данные обновятся
@@ -161,7 +165,7 @@ export class InfiniteQuery {
             !this.isSuccess &&
             !this.isLoading &&
             !this.isError;
-        if (this.isInvalid || shouldSync) {
+        if (this.auxiliary.isInvalid || shouldSync) {
             // т.к. при вызове апдейта, изменяются флаги, на которые подписан data,
             // нужно вызывать этот экшн асинхронно
             when(() => true, this.proceedSync);
@@ -169,31 +173,4 @@ export class InfiniteQuery {
         // возвращаем имеющиеся данные
         return this.storage.data;
     }
-    /**
-     * @description флаг загрузки данных
-     */
-    get isLoading() {
-        return this.auxiliary.isLoading;
-    }
-    /**
-     * @description флаг обозначающий, что последний запрос был зафейлен
-     */
-    get isError() {
-        return this.auxiliary.isError;
-    }
-    /**
-     * @description данные о последней ошибке
-     */
-    get error() {
-        return this.auxiliary.error;
-    }
-    /**
-     * @description флаг обозначающий, что последний запрос был успешно завершен
-     */
-    get isSuccess() {
-        return this.auxiliary.isSuccess;
-    }
-    get isIdle() {
-        return this.auxiliary.isIdle;
-    }
 }

package/MobxQuery/MobxQuery.d.ts

@@ -3,80 +3,106 @@ import { type InfiniteExecutor, InfiniteQuery, type InfiniteQueryParams } from '
 import { Mutation, type MutationExecutor, type MutationParams } from '../Mutation';
 import type { CacheKey, FetchPolicy } from '../types';
 /**
- * @description стандартный обработчик ошибки запроса,
+ * Стандартный обработчик ошибки запроса,
  * будет вызван, если при вызове sync не был передан отдельный onError параметр
  */
 type OnError<TError = unknown> = (error: TError) => void;
 type MobxQueryParams = {
+    /**
+     * Политика получения данных по умолчанию.
+     * @enum cache-first - данные сначала берутся из кеша, если их нет, тогда идет обращение к сети, ответ записывается в кэш
+     * @enum network-only - данные всегда берутся из сети, при этом ответ записывается в кэш
+     */
     fetchPolicy?: FetchPolicy;
+    /**
+     * обработчик ошибок по умолчанию
+     */
     onError?: OnError;
     /**
-     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data по умолчанию.
      * @default false
      */
     enabledAutoFetch?: boolean;
 };
-type CreateQueryParams<TResult, TError> = Omit<QueryParams<TResult, TError>, 'dataStorage'>;
-type CreateInfiniteQueryParams<TResult, TError> = Omit<InfiniteQueryParams<TResult, TError>, 'dataStorage'>;
+type CreateQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<QueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
+    /**
+     * Режим фонового обновления
+     * @default false
+     */
+    isBackground?: TIsBackground;
+};
+type CreateInfiniteQueryParams<TResult, TError, TIsBackground extends boolean> = Omit<InfiniteQueryParams<TResult, TError, TIsBackground>, 'dataStorage' | 'statusStorage' | 'backgroundStatusStorage' | 'submitValidity'> & {
+    /**
+     * Режим фонового обновления
+     * @default false
+     */
+    isBackground?: TIsBackground;
+};
 /**
- * @description Сервис, позволяющий кэшировать данные.
+ * Сервис, позволяющий кэшировать данные.
  */
 export declare class MobxQuery<TDefaultError = void> {
     /**
-     * @description объект соответствия хешей ключей и их значений
+     * Объект соответствия хешей ключей и их значений
      */
     private keys;
     /**
-     * @description Map соответствия хешей ключей к запомненным сторам
+     * Map соответствия хешей ключей к запомненным сторам
      */
-    private cacheableStores;
+    private queriesMap;
     /**
-     * @description фабрика создания хранилищ данных для обычного Query
+     * Фабрика создания хранилищ данных для обычного Query
      */
     private queryDataStorageFactory;
     /**
-     * @description фабрика создания хранилищ данных для Infinite Query
+     * Фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
      */
-    private infiniteQueryDataStorageFactory;
+    private statusStorageFactory;
     /**
-     * @description стандартный обработчик ошибок, будет использован, если не передан другой
+     * Стандартный обработчик ошибок, будет использован, если не передан другой
      */
     private readonly defaultErrorHandler?;
     /**
-     * @description стандартное поведение политики кеширования
+     * Стандартное поведение политики кеширования
      */
     private readonly defaultFetchPolicy;
     /**
-     * @description флаг, отвечающий за автоматический запрос данных при обращении к полю data
+     * Флаг, отвечающий за автоматический запрос данных при обращении к полю data
      * @default false
      */
     private readonly defaultEnabledAutoFetch;
     private serialize;
     constructor({ onError, fetchPolicy, enabledAutoFetch, }?: MobxQueryParams);
     /**
-     * @description метод для инвалидации по списку ключей,
+     * Метод для инвалидации по списку ключей,
      * предполагается использование из домена
      */
     invalidate: (keysParts: CacheKey[]) => void;
+    private submitValidity;
     /**
-     * @description метод инвалидации всех query
+     * Метод инвалидации всех query
      */
     invalidateQueries: () => void;
     /**
-     * @description метод, который занимается проверкой наличия стора по ключу,
+     * Метод, который занимается проверкой наличия квери по ключу,
      * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
      */
     private getCachedQuery;
     /**
-     * @description метод создания стора, кешируется
+     * Метод для создания ключей к внутренним хранилищам
+     */
+    private makeKeys;
+    private getBackgroundStatusStorage;
+    /**
+     * Метод создания стора, кешируется
      */
-    createQuery: <TResult, TError = TDefaultError>(key: CacheKey[], executor: QueryExecutor<TResult>, params?: CreateQueryParams<TResult, TError> | undefined) => Query<TResult, TError>;
+    createQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: QueryExecutor<TResult>, params?: CreateQueryParams<TResult, TError, TIsBackground> | undefined) => Query<TResult, TError, TIsBackground>;
     /**
-     * @description метод создания инфинит стора, кешируется
+     * Метод создания инфинит стора, кешируется
      */
-    createInfiniteQuery: <TResult, TError = TDefaultError>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError> | undefined) => InfiniteQuery<TResult, TError>;
+    createInfiniteQuery: <TResult, TError = TDefaultError, TIsBackground extends boolean = false>(key: CacheKey[], executor: InfiniteExecutor<TResult>, params?: CreateInfiniteQueryParams<TResult, TError, TIsBackground> | undefined) => InfiniteQuery<TResult, TError, TIsBackground>;
     /**
-     * @description метод создания мутации, не кешируется
+     * Метод создания мутации, не кешируется
      */
     createMutation: <TResult, TError = TDefaultError, TExecutorParams = void>(executor: MutationExecutor<TResult, TExecutorParams>, params?: MutationParams<TResult, TError> | undefined) => Mutation<TResult, TError, TExecutorParams>;
 }

package/MobxQuery/MobxQuery.js

@@ -2,71 +2,99 @@ import { Query } from '../Query';
 import { InfiniteQuery, } from '../InfiniteQuery';
 import { Mutation, } from '../Mutation';
 import { DataStorageFactory } from '../DataStorage';
+import { StatusStorageFactory } from '../StatusStorage';
+import { AdaptableMap } from '../AdaptableMap';
 /**
- * @description время, спустя которое, запись о query c network-only будет удалена
+ * Время, спустя которое, запись о query c network-only будет удалена
  */
 const DEFAULT_TIME_TO_CLEAN = 100;
 /**
- * @description Сервис, позволяющий кэшировать данные.
+ * Сервис, позволяющий кэшировать данные.
  */
 export class MobxQuery {
     constructor({ onError, fetchPolicy = 'cache-first', enabledAutoFetch = false, } = {}) {
         /**
-         * @description объект соответствия хешей ключей и их значений
+         * Объект соответствия хешей ключей и их значений
          */
-        this.keys = {};
+        this.keys = new Map();
         /**
-         * @description Map соответствия хешей ключей к запомненным сторам
+         * Map соответствия хешей ключей к запомненным сторам
          */
-        this.cacheableStores = new Map();
+        this.queriesMap = new AdaptableMap();
         /**
-         * @description фабрика создания хранилищ данных для обычного Query
+         * Фабрика создания хранилищ данных для обычного Query
          */
         this.queryDataStorageFactory = new DataStorageFactory();
         /**
-         * @description фабрика создания хранилищ данных для Infinite Query
+         * Фабрика создания хранилищ статусов между экземплярами Query и экземллярами Infinite Query.
          */
-        this.infiniteQueryDataStorageFactory = new DataStorageFactory();
+        this.statusStorageFactory = new StatusStorageFactory();
         this.serialize = (data) => JSON.stringify(data);
         /**
-         * @description метод для инвалидации по списку ключей,
+         * Метод для инвалидации по списку ключей,
          * предполагается использование из домена
          */
         this.invalidate = (keysParts) => {
-            // сет сериализовонных ключей
+            // Сет сериализовонных ключей
             const keysSet = new Set(keysParts.map(this.serialize));
-            Object.keys(this.keys).forEach((key) => {
-                var _a;
-                const value = this.keys[key];
-                // проверяем, есть ли пересечение между закешированными ключами и набором ключей для инвалидации
-                const hasTouchedElement = value.some((valuePart) => keysSet.has(this.serialize(valuePart)));
+            [...this.keys.keys()].forEach((keyHash) => {
+                const key = this.keys.get(keyHash);
+                if (!key) {
+                    return;
+                }
+                // Проверяем, есть ли пересечение между закешированными ключами и набором ключей для инвалидации
+                const hasTouchedElement = key.some((valuePart) => keysSet.has(this.serialize(valuePart)));
                 if (hasTouchedElement) {
-                    (_a = this.cacheableStores.get(key)) === null || _a === void 0 ? void 0 : _a.invalidate();
+                    const query = this.queriesMap.get(keyHash);
+                    if (query) {
+                        query.invalidate();
+                        // Конвертируем инвалидированный квери в слабый,
+                        // чтобы сборщик мусора мог удалить неиспользуемые квери
+                        this.queriesMap.convertToWeak(keyHash);
+                    }
                 }
             });
         };
+        // Метод для подтверждения того, что квери успешно получил валидные данные
+        this.submitValidity = (keyHash) => {
+            // конвертируем квери в сильный,
+            // чтобы сборщик мусора не удалил наш кеш преждевременно
+            this.queriesMap.convertToStrong(keyHash);
+        };
         /**
-         * @description метод инвалидации всех query
+         * Метод инвалидации всех query
          */
         this.invalidateQueries = () => {
-            [...this.cacheableStores.entries()].forEach(([, store]) => {
-                store.invalidate();
+            [...this.keys.keys()].forEach((keyHash) => {
+                var _a;
+                (_a = this.queriesMap.get(keyHash)) === null || _a === void 0 ? void 0 : _a.invalidate();
+                this.queriesMap.convertToWeak(keyHash);
             });
         };
         /**
-         * @description метод, который занимается проверкой наличия стора по ключу,
+         * Метод, который занимается проверкой наличия квери по ключу,
          * и если нет, создает новый, добавляет его к себе в память, и возвращает его пользователю
          */
-        this.getCachedQuery = (key, createStore, fetchPolicy) => {
-            // создаем хэш ключа с добавляем к ключу значения fetchPolicy,
-            // чтобы query c одинаковым ключом, но разным fetchPolicy не пересекались бы
-            const keyHash = this.serialize([...key, fetchPolicy]);
-            if (this.cacheableStores.has(keyHash)) {
-                return this.cacheableStores.get(keyHash);
+        this.getCachedQuery = (key, createInstance, type, createParams) => {
+            var _a, _b;
+            const fetchPolicy = (createParams === null || createParams === void 0 ? void 0 : createParams.fetchPolicy) || this.defaultFetchPolicy;
+            const keys = this.makeKeys(key, fetchPolicy, (_a = createParams === null || createParams === void 0 ? void 0 : createParams.isBackground) !== null && _a !== void 0 ? _a : false, type);
+            const cachedQuery = this.queriesMap.get(keys.queryKeyHash);
+            if (cachedQuery) {
+                return cachedQuery;
             }
-            const store = createStore();
-            this.cacheableStores.set(keyHash, store);
-            this.keys[keyHash] = key;
+            const query = createInstance({
+                onError: ((createParams === null || createParams === void 0 ? void 0 : createParams.onError) ||
+                    this.defaultErrorHandler),
+                enabledAutoFetch: (_b = createParams === null || createParams === void 0 ? void 0 : createParams.enabledAutoFetch) !== null && _b !== void 0 ? _b : this.defaultEnabledAutoFetch,
+                fetchPolicy: fetchPolicy,
+                dataStorage: this.queryDataStorageFactory.getStorage(keys.dataKeyHash),
+                statusStorage: this.statusStorageFactory.getStorage(keys.statusKeyHash),
+                backgroundStatusStorage: this.getBackgroundStatusStorage(keys.backgroundStatusKeyHash, Boolean(createParams === null || createParams === void 0 ? void 0 : createParams.isBackground)),
+                submitValidity: () => this.submitValidity(keys.queryKeyHash),
+            });
+            this.queriesMap.set(keys.queryKeyHash, query);
+            this.keys.set(keys.queryKeyHash, keys.queryKey);
             // Ожидается, что network-only квери не должны кешироваться,
             // но, с введением StrictMode в реакт 18, проявилась проблема,
             // что network-only квери, созданные в одном реакт компоненте,
@@ -76,36 +104,45 @@ export class MobxQuery {
             // делают по отдельному запросу к данным единомоментно,
             if (fetchPolicy === 'network-only') {
                 setTimeout(() => {
-                    this.cacheableStores.delete(keyHash);
-                    delete this.keys[keyHash];
+                    this.queriesMap.delete(keys.queryKeyHash);
+                    this.keys.delete(keys.queryKeyHash);
                 }, DEFAULT_TIME_TO_CLEAN);
             }
-            return store;
+            return query;
         };
         /**
-         * @description метод создания стора, кешируется
+         * Метод для создания ключей к внутренним хранилищам
          */
-        this.createQuery = (key, executor, params) => {
-            const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy;
-            return this.getCachedQuery(key, () => {
-                var _a;
-                return new Query(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
-                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, fetchPolicy: fetchPolicy, dataStorage: this.queryDataStorageFactory.getStorage(key) }));
-            }, fetchPolicy);
+        this.makeKeys = (rootKey, fetchPolicy, isBackground, type) => {
+            const queryKey = [...rootKey, { fetchPolicy, isBackground, type }];
+            const queryKeyHash = this.serialize(queryKey);
+            const dataKeyHash = this.serialize([...rootKey, { type }]);
+            const statusKeyHash = this.serialize([...rootKey, { type }]);
+            const backgroundStatusKeyHash = this.serialize([
+                ...rootKey,
+                { type, isBackground },
+            ]);
+            return {
+                queryKey,
+                queryKeyHash,
+                statusKeyHash,
+                backgroundStatusKeyHash,
+                dataKeyHash,
+            };
         };
+        this.getBackgroundStatusStorage = (keyHash, hasBackground) => (hasBackground
+            ? this.statusStorageFactory.getStorage(keyHash)
+            : null);
         /**
-         * @description метод создания инфинит стора, кешируется
+         * Метод создания стора, кешируется
          */
-        this.createInfiniteQuery = (key, executor, params) => {
-            const fetchPolicy = (params === null || params === void 0 ? void 0 : params.fetchPolicy) || this.defaultFetchPolicy || '';
-            return this.getCachedQuery(key, () => {
-                var _a;
-                return new InfiniteQuery(executor, Object.assign(Object.assign({}, params), { onError: ((params === null || params === void 0 ? void 0 : params.onError) ||
-                        this.defaultErrorHandler), enabledAutoFetch: (_a = params === null || params === void 0 ? void 0 : params.enabledAutoFetch) !== null && _a !== void 0 ? _a : this.defaultEnabledAutoFetch, dataStorage: this.infiniteQueryDataStorageFactory.getStorage(key), fetchPolicy: fetchPolicy }));
-            }, fetchPolicy);
-        };
+        this.createQuery = (key, executor, params) => this.getCachedQuery(key, (internalParams) => new Query(executor, Object.assign(Object.assign(Object.assign({}, params), internalParams), { dataStorage: internalParams.dataStorage })), Query.name, params);
+        /**
+         * Метод создания инфинит стора, кешируется
+         */
+        this.createInfiniteQuery = (key, executor, params) => this.getCachedQuery(key, (internalParams) => new InfiniteQuery(executor, Object.assign(Object.assign(Object.assign({}, params), internalParams), { dataStorage: internalParams.dataStorage })), InfiniteQuery.name, params);
         /**
-         * @description метод создания мутации, не кешируется
+         * Метод создания мутации, не кешируется
          */
         this.createMutation = (executor, params) => new Mutation(executor, Object.assign(Object.assign({}, params), { onError: (params === null || params === void 0 ? void 0 : params.onError) || this.defaultErrorHandler }));
         this.defaultErrorHandler = onError;

package/Mutation/Mutation.d.ts

@@ -1,57 +1,34 @@
+import { AuxiliaryQuery } from '../AuxiliaryQuery';
 import type { QueryBaseActions, Sync, SyncParams } from '../types';
+import { QueryContainer } from '../QueryContainer';
 /**
- * @description исполнитель запроса
+ * Исполнитель запроса
  */
 export type MutationExecutor<TResult, TParams> = (params: TParams) => Promise<TResult>;
 export type MutationParams<TResult, TError> = {
     /**
-     * @description обработчик ошибки, вызываемый по умолчанию
+     * Обработчик ошибки, вызываемый по умолчанию
      */
     onError?: SyncParams<TResult, TError>['onError'];
 };
 /**
- * @description простой стор для запросов, которые не требуют кэширования,
+ * Простой квери для запросов, которые не требуют кэширования,
  * пример - POST запросы
  */
-export declare class Mutation<TResult, TError = void, TExecutorParams = void> implements QueryBaseActions<TResult, TError, TExecutorParams> {
+export declare class Mutation<TResult, TError = void, TExecutorParams = void> extends QueryContainer<TError, AuxiliaryQuery<TResult, TError>, false> implements QueryBaseActions<TResult, TError, TExecutorParams> {
+    private readonly executor;
     /**
-     * @description инстанс вспомогательного стора
+     * Обработчик ошибки, вызываемый по умолчанию
      */
-    private auxiliary;
-    /**
-     * @description исполнитель запроса, ожидается,
-     * что будет использоваться что-то из слоя sources
-     */
-    private executor;
-    /**
-     * @description обработчик ошибки, вызываемый по умолчанию
-     */
-    private defaultOnError?;
+    private readonly defaultOnError?;
     constructor(executor: MutationExecutor<TResult, TExecutorParams>, { onError }?: MutationParams<TResult, TError>);
     /**
-     * @description синхронный метод получения/отправки данных
+     * Синхронный метод получения/отправки данных
      */
     sync: Sync<TResult, TError, TExecutorParams>;
     /**
-     * @description асинхронный метод получения/отправки данных,
+     * Асинхронный метод получения/отправки данных,
      * предполагается, что нужно будет самостоятельно обрабатывать ошибку
      */
     async: (params: TExecutorParams) => Promise<TResult>;
-    /**
-     * @description флаг загрузки данных
-     */
-    get isLoading(): boolean;
-    /**
-     * @description флаг обозначающий, что последний запрос был зафейлен
-     */
-    get isError(): boolean;
-    /**
-     * @description данные о последней ошибке
-     */
-    get error(): TError | undefined;
-    /**
-     * @description флаг обозначающий, что последний запрос был успешно завершен
-     */
-    get isSuccess(): boolean;
-    get isIdle(): boolean;
 }