fastapi-rtk 1.0.2 → 1.0.3

package/dist/.external/cjs/ajv@8.17.1/ajv/dist/vocabularies/applicator/dependencies.cjs

@@ -8,13 +8,13 @@ var hasRequiredDependencies;
 function requireDependencies() {
   if (hasRequiredDependencies) return dependencies.__exports;
   hasRequiredDependencies = 1;
-  (function(exports2) {
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.validateSchemaDeps = exports2.validatePropertyDeps = exports2.error = void 0;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.validateSchemaDeps = exports$1.validatePropertyDeps = exports$1.error = void 0;
     const codegen_1 = index.__require();
     const util_1 = util.__require();
     const code_1 = code.__require();
-    exports2.error = {
+    exports$1.error = {
       message: ({ params: { property, depsCount, deps } }) => {
         const property_ies = depsCount === 1 ? "property" : "properties";
         return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
@@ -29,7 +29,7 @@ function requireDependencies() {
       keyword: "dependencies",
       type: "object",
       schemaType: "object",
-      error: exports2.error,
+      error: exports$1.error,
       code(cxt) {
         const [propDeps, schDeps] = splitDependencies(cxt);
         validatePropertyDeps(cxt, propDeps);
@@ -75,7 +75,7 @@ function requireDependencies() {
         }
       }
     }
-    exports2.validatePropertyDeps = validatePropertyDeps;
+    exports$1.validatePropertyDeps = validatePropertyDeps;
     function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
       const { gen, data, keyword, it } = cxt;
       const valid = gen.name("valid");
@@ -94,8 +94,8 @@ function requireDependencies() {
         cxt.ok(valid);
       }
     }
-    exports2.validateSchemaDeps = validateSchemaDeps;
-    exports2.default = def;
+    exports$1.validateSchemaDeps = validateSchemaDeps;
+    exports$1.default = def;
   })(dependencies.__exports);
   return dependencies.__exports;
 }

package/dist/.external/cjs/{i18next@25.6.0_typescript@5.9.3 → i18next@25.6.2_typescript@5.9.3}/i18next/dist/esm/i18next.cjs

@@ -2134,7 +2134,9 @@ class I18n extends EventEmitter {
     return rtlLngs.indexOf(languageUtils.getLanguagePartFromCode(lng)) > -1 || lng.toLowerCase().indexOf("-arab") > 1 ? "rtl" : "ltr";
   }
   static createInstance(options = {}, callback) {
-    return new I18n(options, callback);
+    const instance2 = new I18n(options, callback);
+    instance2.createInstance = I18n.createInstance;
+    return instance2;
   }
   cloneInstance(options = {}, callback = noop) {
     const forkResourceStore = options.forkResourceStore;
@@ -2198,7 +2200,6 @@ class I18n extends EventEmitter {
   }
 }
 const instance = I18n.createInstance();
-instance.createInstance = I18n.createInstance;
 const createInstance = instance.createInstance;
 instance.dir;
 instance.init;

package/dist/.external/cjs/lodash@4.17.21/lodash/_cloneBuffer.cjs

@@ -7,9 +7,9 @@ var hasRequired_cloneBuffer;
 function require_cloneBuffer() {
   if (hasRequired_cloneBuffer) return _cloneBuffer.__module.exports;
   hasRequired_cloneBuffer = 1;
-  (function(module2, exports2) {
+  (function(module2, exports$1) {
     var root = _root.__require();
-    var freeExports = exports2 && !exports2.nodeType && exports2;
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
     var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;

package/dist/.external/cjs/lodash@4.17.21/lodash/_nodeUtil.cjs

@@ -7,9 +7,9 @@ var hasRequired_nodeUtil;
 function require_nodeUtil() {
   if (hasRequired_nodeUtil) return _nodeUtil.__module.exports;
   hasRequired_nodeUtil = 1;
-  (function(module2, exports2) {
+  (function(module2, exports$1) {
     var freeGlobal = _freeGlobal.__require();
-    var freeExports = exports2 && !exports2.nodeType && exports2;
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
     var freeProcess = moduleExports && freeGlobal.process;

package/dist/.external/cjs/lodash@4.17.21/lodash/fp/_mapping.cjs

@@ -5,8 +5,8 @@ var hasRequired_mapping;
 function require_mapping() {
   if (hasRequired_mapping) return _mapping.__exports;
   hasRequired_mapping = 1;
-  (function(exports2) {
-    exports2.aliasToReal = {
+  (function(exports$1) {
+    exports$1.aliasToReal = {
       // Lodash aliases.
       "each": "forEach",
       "eachRight": "forEachRight",
@@ -71,7 +71,7 @@ function require_mapping() {
       "whereEq": "isMatch",
       "zipObj": "zipObject"
     };
-    exports2.aryMethod = {
+    exports$1.aryMethod = {
       "1": [
         "assignAll",
         "assignInAll",
@@ -306,12 +306,12 @@ function require_mapping() {
         "updateWith"
       ]
     };
-    exports2.aryRearg = {
+    exports$1.aryRearg = {
       "2": [1, 0],
       "3": [2, 0, 1],
       "4": [3, 2, 0, 1]
     };
-    exports2.iterateeAry = {
+    exports$1.iterateeAry = {
       "dropRightWhile": 1,
       "dropWhile": 1,
       "every": 1,
@@ -349,11 +349,11 @@ function require_mapping() {
       "times": 1,
       "transform": 2
     };
-    exports2.iterateeRearg = {
+    exports$1.iterateeRearg = {
       "mapKeys": [1],
       "reduceRight": [1, 0]
     };
-    exports2.methodRearg = {
+    exports$1.methodRearg = {
       "assignInAllWith": [1, 0],
       "assignInWith": [1, 2, 0],
       "assignAllWith": [1, 0],
@@ -384,7 +384,7 @@ function require_mapping() {
       "xorWith": [1, 2, 0],
       "zipWith": [1, 2, 0]
     };
-    exports2.methodSpread = {
+    exports$1.methodSpread = {
       "assignAll": { "start": 0 },
       "assignAllWith": { "start": 0 },
       "assignInAll": { "start": 0 },
@@ -400,7 +400,7 @@ function require_mapping() {
       "without": { "start": 1 },
       "zipAll": { "start": 0 }
     };
-    exports2.mutate = {
+    exports$1.mutate = {
       "array": {
         "fill": true,
         "pull": true,
@@ -437,8 +437,8 @@ function require_mapping() {
         "updateWith": true
       }
     };
-    exports2.realToAlias = (function() {
-      var hasOwnProperty = Object.prototype.hasOwnProperty, object = exports2.aliasToReal, result = {};
+    exports$1.realToAlias = (function() {
+      var hasOwnProperty = Object.prototype.hasOwnProperty, object = exports$1.aliasToReal, result = {};
       for (var key in object) {
         var value = object[key];
         if (hasOwnProperty.call(result, value)) {
@@ -449,7 +449,7 @@ function require_mapping() {
       }
       return result;
     })();
-    exports2.remap = {
+    exports$1.remap = {
       "assignAll": "assign",
       "assignAllWith": "assignWith",
       "assignInAll": "assignIn",
@@ -483,7 +483,7 @@ function require_mapping() {
       "trimCharsStart": "trimStart",
       "zipAll": "zip"
     };
-    exports2.skipFixed = {
+    exports$1.skipFixed = {
       "castArray": true,
       "flow": true,
       "flowRight": true,
@@ -492,7 +492,7 @@ function require_mapping() {
       "rearg": true,
       "runInContext": true
     };
-    exports2.skipRearg = {
+    exports$1.skipRearg = {
       "add": true,
       "assign": true,
       "assignIn": true,

package/dist/.external/cjs/lodash@4.17.21/lodash/isBuffer.cjs

@@ -8,9 +8,9 @@ var hasRequiredIsBuffer;
 function requireIsBuffer() {
   if (hasRequiredIsBuffer) return isBuffer.__module.exports;
   hasRequiredIsBuffer = 1;
-  (function(module2, exports2) {
+  (function(module2, exports$1) {
     var root = _root.__require(), stubFalse$1 = stubFalse.__require();
-    var freeExports = exports2 && !exports2.nodeType && exports2;
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
     var Buffer = moduleExports ? root.Buffer : void 0;

package/dist/.external/cjs/lodash@4.17.21/lodash/lodash.cjs

@@ -15,7 +15,7 @@ var hasRequiredLodash;
 function requireLodash() {
   if (hasRequiredLodash) return lodash$1.__module.exports;
   hasRequiredLodash = 1;
-  (function(module2, exports2) {
+  (function(module2, exports$1) {
     (function() {
       var undefined$1;
       var VERSION = "4.17.21";
@@ -343,7 +343,7 @@ function requireLodash() {
       var freeGlobal = typeof _commonjsHelpers.commonjsGlobal == "object" && _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.Object === Object && _commonjsHelpers.commonjsGlobal;
       var freeSelf = typeof self == "object" && self && self.Object === Object && self;
       var root = freeGlobal || freeSelf || Function("return this")();
-      var freeExports = exports2 && !exports2.nodeType && exports2;
+      var freeExports = exports$1 && !exports$1.nodeType && exports$1;
       var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
       var moduleExports = freeModule && freeModule.exports === freeExports;
       var freeProcess = moduleExports && freeGlobal.process;

package/dist/.external/esm/@tanstack_query-core@5.90.7/@tanstack/query-core/build/modern/hydration.mjs

@@ -0,0 +1,148 @@
+import { tryResolveSync } from "./thenable.mjs";
+import { noop } from "./utils.mjs";
+function defaultTransformerFn(data) {
+  return data;
+}
+function dehydrateMutation(mutation) {
+  return {
+    mutationKey: mutation.options.mutationKey,
+    state: mutation.state,
+    ...mutation.options.scope && { scope: mutation.options.scope },
+    ...mutation.meta && { meta: mutation.meta }
+  };
+}
+function dehydrateQuery(query, serializeData, shouldRedactErrors) {
+  const dehydratePromise = () => {
+    var _a;
+    const promise = (_a = query.promise) == null ? void 0 : _a.then(serializeData).catch((error) => {
+      if (!shouldRedactErrors(error)) {
+        return Promise.reject(error);
+      }
+      if (process.env.NODE_ENV !== "production") {
+        console.error(
+          `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`
+        );
+      }
+      return Promise.reject(new Error("redacted"));
+    });
+    promise == null ? void 0 : promise.catch(noop);
+    return promise;
+  };
+  return {
+    dehydratedAt: Date.now(),
+    state: {
+      ...query.state,
+      ...query.state.data !== void 0 && {
+        data: serializeData(query.state.data)
+      }
+    },
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.state.status === "pending" && {
+      promise: dehydratePromise()
+    },
+    ...query.meta && { meta: query.meta }
+  };
+}
+function defaultShouldDehydrateMutation(mutation) {
+  return mutation.state.isPaused;
+}
+function defaultShouldDehydrateQuery(query) {
+  return query.state.status === "success";
+}
+function defaultShouldRedactErrors(_) {
+  return true;
+}
+function dehydrate(client, options = {}) {
+  var _a, _b, _c, _d;
+  const filterMutation = options.shouldDehydrateMutation ?? ((_a = client.getDefaultOptions().dehydrate) == null ? void 0 : _a.shouldDehydrateMutation) ?? defaultShouldDehydrateMutation;
+  const mutations = client.getMutationCache().getAll().flatMap(
+    (mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []
+  );
+  const filterQuery = options.shouldDehydrateQuery ?? ((_b = client.getDefaultOptions().dehydrate) == null ? void 0 : _b.shouldDehydrateQuery) ?? defaultShouldDehydrateQuery;
+  const shouldRedactErrors = options.shouldRedactErrors ?? ((_c = client.getDefaultOptions().dehydrate) == null ? void 0 : _c.shouldRedactErrors) ?? defaultShouldRedactErrors;
+  const serializeData = options.serializeData ?? ((_d = client.getDefaultOptions().dehydrate) == null ? void 0 : _d.serializeData) ?? defaultTransformerFn;
+  const queries = client.getQueryCache().getAll().flatMap(
+    (query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : []
+  );
+  return { mutations, queries };
+}
+function hydrate(client, dehydratedState, options) {
+  var _a, _b;
+  if (typeof dehydratedState !== "object" || dehydratedState === null) {
+    return;
+  }
+  const mutationCache = client.getMutationCache();
+  const queryCache = client.getQueryCache();
+  const deserializeData = ((_a = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _a.deserializeData) ?? ((_b = client.getDefaultOptions().hydrate) == null ? void 0 : _b.deserializeData) ?? defaultTransformerFn;
+  const mutations = dehydratedState.mutations || [];
+  const queries = dehydratedState.queries || [];
+  mutations.forEach(({ state, ...mutationOptions }) => {
+    var _a2, _b2;
+    mutationCache.build(
+      client,
+      {
+        ...(_a2 = client.getDefaultOptions().hydrate) == null ? void 0 : _a2.mutations,
+        ...(_b2 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _b2.mutations,
+        ...mutationOptions
+      },
+      state
+    );
+  });
+  queries.forEach(
+    ({ queryKey, state, queryHash, meta, promise, dehydratedAt }) => {
+      var _a2, _b2;
+      const syncData = promise ? tryResolveSync(promise) : void 0;
+      const rawData = state.data === void 0 ? syncData == null ? void 0 : syncData.data : state.data;
+      const data = rawData === void 0 ? rawData : deserializeData(rawData);
+      let query = queryCache.get(queryHash);
+      const existingQueryIsPending = (query == null ? void 0 : query.state.status) === "pending";
+      const existingQueryIsFetching = (query == null ? void 0 : query.state.fetchStatus) === "fetching";
+      if (query) {
+        const hasNewerSyncData = syncData && // We only need this undefined check to handle older dehydration
+        // payloads that might not have dehydratedAt
+        dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
+        if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
+          const { fetchStatus: _ignored, ...serializedState } = state;
+          query.setState({
+            ...serializedState,
+            data
+          });
+        }
+      } else {
+        query = queryCache.build(
+          client,
+          {
+            ...(_a2 = client.getDefaultOptions().hydrate) == null ? void 0 : _a2.queries,
+            ...(_b2 = options == null ? void 0 : options.defaultOptions) == null ? void 0 : _b2.queries,
+            queryKey,
+            queryHash,
+            meta
+          },
+          // Reset fetch status to idle to avoid
+          // query being stuck in fetching state upon hydration
+          {
+            ...state,
+            data,
+            fetchStatus: "idle",
+            status: data !== void 0 ? "success" : state.status
+          }
+        );
+      }
+      if (promise && !existingQueryIsPending && !existingQueryIsFetching && // Only hydrate if dehydration is newer than any existing data,
+      // this is always true for new queries
+      (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) {
+        query.fetch(void 0, {
+          // RSC transformed promises are not thenable
+          initialPromise: Promise.resolve(promise).then(deserializeData)
+        }).catch(noop);
+      }
+    }
+  );
+}
+export {
+  defaultShouldDehydrateMutation,
+  defaultShouldDehydrateQuery,
+  dehydrate,
+  hydrate
+};

package/dist/.external/esm/{@tanstack_query-core@5.90.5 → @tanstack_query-core@5.90.7}/@tanstack/query-core/build/modern/infiniteQueryBehavior.mjs

@@ -110,6 +110,16 @@ function getPreviousPageParam(options, { pages, pageParams }) {
   var _a;
   return pages.length > 0 ? (_a = options.getPreviousPageParam) == null ? void 0 : _a.call(options, pages[0], pages, pageParams[0], pageParams) : void 0;
 }
+function hasNextPage(options, data) {
+  if (!data) return false;
+  return getNextPageParam(options, data) != null;
+}
+function hasPreviousPage(options, data) {
+  if (!data || !options.getPreviousPageParam) return false;
+  return getPreviousPageParam(options, data) != null;
+}
 export {
+  hasNextPage,
+  hasPreviousPage,
   infiniteQueryBehavior
 };

package/dist/.external/esm/@tanstack_query-core@5.90.7/@tanstack/query-core/build/modern/infiniteQueryObserver.mjs

@@ -0,0 +1,66 @@
+import { QueryObserver } from "./queryObserver.mjs";
+import { infiniteQueryBehavior, hasPreviousPage, hasNextPage } from "./infiniteQueryBehavior.mjs";
+var InfiniteQueryObserver = class extends QueryObserver {
+  constructor(client, options) {
+    super(client, options);
+  }
+  bindMethods() {
+    super.bindMethods();
+    this.fetchNextPage = this.fetchNextPage.bind(this);
+    this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+  }
+  setOptions(options) {
+    super.setOptions({
+      ...options,
+      behavior: infiniteQueryBehavior()
+    });
+  }
+  getOptimisticResult(options) {
+    options.behavior = infiniteQueryBehavior();
+    return super.getOptimisticResult(options);
+  }
+  fetchNextPage(options) {
+    return this.fetch({
+      ...options,
+      meta: {
+        fetchMore: { direction: "forward" }
+      }
+    });
+  }
+  fetchPreviousPage(options) {
+    return this.fetch({
+      ...options,
+      meta: {
+        fetchMore: { direction: "backward" }
+      }
+    });
+  }
+  createResult(query, options) {
+    var _a, _b;
+    const { state } = query;
+    const parentResult = super.createResult(query, options);
+    const { isFetching, isRefetching, isError, isRefetchError } = parentResult;
+    const fetchDirection = (_b = (_a = state.fetchMeta) == null ? void 0 : _a.fetchMore) == null ? void 0 : _b.direction;
+    const isFetchNextPageError = isError && fetchDirection === "forward";
+    const isFetchingNextPage = isFetching && fetchDirection === "forward";
+    const isFetchPreviousPageError = isError && fetchDirection === "backward";
+    const isFetchingPreviousPage = isFetching && fetchDirection === "backward";
+    const result = {
+      ...parentResult,
+      fetchNextPage: this.fetchNextPage,
+      fetchPreviousPage: this.fetchPreviousPage,
+      hasNextPage: hasNextPage(options, state.data),
+      hasPreviousPage: hasPreviousPage(options, state.data),
+      isFetchNextPageError,
+      isFetchingNextPage,
+      isFetchPreviousPageError,
+      isFetchingPreviousPage,
+      isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,
+      isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
+    };
+    return result;
+  }
+};
+export {
+  InfiniteQueryObserver
+};

package/dist/.external/esm/@tanstack_query-core@5.90.7/@tanstack/query-core/build/modern/mutationObserver.mjs

@@ -0,0 +1,140 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _client, _currentResult, _currentMutation, _mutateOptions, _MutationObserver_instances, updateResult_fn, notify_fn, _a;
+import { getDefaultState } from "./mutation.mjs";
+import { notifyManager } from "./notifyManager.mjs";
+import { Subscribable } from "./subscribable.mjs";
+import { shallowEqualObjects, hashKey } from "./utils.mjs";
+var MutationObserver = (_a = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    __privateAdd(this, _MutationObserver_instances);
+    __privateAdd(this, _client);
+    __privateAdd(this, _currentResult);
+    __privateAdd(this, _currentMutation);
+    __privateAdd(this, _mutateOptions);
+    __privateSet(this, _client, client);
+    this.setOptions(options);
+    this.bindMethods();
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+  setOptions(options) {
+    var _a2;
+    const prevOptions = this.options;
+    this.options = __privateGet(this, _client).defaultMutationOptions(options);
+    if (!shallowEqualObjects(this.options, prevOptions)) {
+      __privateGet(this, _client).getMutationCache().notify({
+        type: "observerOptionsUpdated",
+        mutation: __privateGet(this, _currentMutation),
+        observer: this
+      });
+    }
+    if ((prevOptions == null ? void 0 : prevOptions.mutationKey) && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) {
+      this.reset();
+    } else if (((_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.state.status) === "pending") {
+      __privateGet(this, _currentMutation).setOptions(this.options);
+    }
+  }
+  onUnsubscribe() {
+    var _a2;
+    if (!this.hasListeners()) {
+      (_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.removeObserver(this);
+    }
+  }
+  onMutationUpdate(action) {
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    __privateMethod(this, _MutationObserver_instances, notify_fn).call(this, action);
+  }
+  getCurrentResult() {
+    return __privateGet(this, _currentResult);
+  }
+  reset() {
+    var _a2;
+    (_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.removeObserver(this);
+    __privateSet(this, _currentMutation, void 0);
+    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
+    __privateMethod(this, _MutationObserver_instances, notify_fn).call(this);
+  }
+  mutate(variables, options) {
+    var _a2;
+    __privateSet(this, _mutateOptions, options);
+    (_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.removeObserver(this);
+    __privateSet(this, _currentMutation, __privateGet(this, _client).getMutationCache().build(__privateGet(this, _client), this.options));
+    __privateGet(this, _currentMutation).addObserver(this);
+    return __privateGet(this, _currentMutation).execute(variables);
+  }
+}, _client = new WeakMap(), _currentResult = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _MutationObserver_instances = new WeakSet(), updateResult_fn = function() {
+  var _a2;
+  const state = ((_a2 = __privateGet(this, _currentMutation)) == null ? void 0 : _a2.state) ?? getDefaultState();
+  __privateSet(this, _currentResult, {
+    ...state,
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success",
+    isError: state.status === "error",
+    isIdle: state.status === "idle",
+    mutate: this.mutate,
+    reset: this.reset
+  });
+}, notify_fn = function(action) {
+  notifyManager.batch(() => {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
+    if (__privateGet(this, _mutateOptions) && this.hasListeners()) {
+      const variables = __privateGet(this, _currentResult).variables;
+      const onMutateResult = __privateGet(this, _currentResult).context;
+      const context = {
+        client: __privateGet(this, _client),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      if ((action == null ? void 0 : action.type) === "success") {
+        (_b = (_a2 = __privateGet(this, _mutateOptions)).onSuccess) == null ? void 0 : _b.call(
+          _a2,
+          action.data,
+          variables,
+          onMutateResult,
+          context
+        );
+        (_d = (_c = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _d.call(
+          _c,
+          action.data,
+          null,
+          variables,
+          onMutateResult,
+          context
+        );
+      } else if ((action == null ? void 0 : action.type) === "error") {
+        (_f = (_e = __privateGet(this, _mutateOptions)).onError) == null ? void 0 : _f.call(
+          _e,
+          action.error,
+          variables,
+          onMutateResult,
+          context
+        );
+        (_h = (_g = __privateGet(this, _mutateOptions)).onSettled) == null ? void 0 : _h.call(
+          _g,
+          void 0,
+          action.error,
+          variables,
+          onMutateResult,
+          context
+        );
+      }
+    }
+    this.listeners.forEach((listener) => {
+      listener(__privateGet(this, _currentResult));
+    });
+  });
+}, _a);
+export {
+  MutationObserver
+};