@tanstack/eslint-plugin-query 5.94.4 → 5.95.0

package/build/modern/rules.cjs

@@ -0,0 +1,1362 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name8 in all)
+    __defProp(target, name8, { get: all[name8], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rules.ts
+var rules_exports = {};
+__export(rules_exports, {
+  rules: () => rules
+});
+module.exports = __toCommonJS(rules_exports);
+
+// src/rules/exhaustive-deps/exhaustive-deps.rule.ts
+var import_utils4 = require("@typescript-eslint/utils");
+
+// src/utils/ast-utils.ts
+var import_utils = require("@typescript-eslint/utils");
+
+// src/utils/unique-by.ts
+function uniqueBy(arr, fn) {
+  return arr.filter((x, i, a) => a.findIndex((y) => fn(x) === fn(y)) === i);
+}
+
+// src/utils/ast-utils.ts
+var ASTUtils = {
+  isNodeOfOneOf(node, types) {
+    return types.includes(node.type);
+  },
+  isIdentifier(node) {
+    return node.type === import_utils.AST_NODE_TYPES.Identifier;
+  },
+  isIdentifierWithName(node, name8) {
+    return ASTUtils.isIdentifier(node) && node.name === name8;
+  },
+  isIdentifierWithOneOfNames(node, name8) {
+    return ASTUtils.isIdentifier(node) && name8.includes(node.name);
+  },
+  isProperty(node) {
+    return node.type === import_utils.AST_NODE_TYPES.Property;
+  },
+  isObjectExpression(node) {
+    return node.type === import_utils.AST_NODE_TYPES.ObjectExpression;
+  },
+  isPropertyWithIdentifierKey(node, key) {
+    return ASTUtils.isProperty(node) && ASTUtils.isIdentifierWithName(node.key, key);
+  },
+  findPropertyWithIdentifierKey(properties, key) {
+    return properties.find(
+      (x) => ASTUtils.isPropertyWithIdentifierKey(x, key)
+    );
+  },
+  getNestedIdentifiers(node) {
+    const identifiers = [];
+    if (ASTUtils.isIdentifier(node)) {
+      identifiers.push(node);
+    }
+    if ("arguments" in node) {
+      node.arguments.forEach((x) => {
+        identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+      });
+    }
+    if ("elements" in node) {
+      node.elements.forEach((x) => {
+        if (x !== null) {
+          identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+        }
+      });
+    }
+    if ("properties" in node) {
+      node.properties.forEach((x) => {
+        identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+      });
+    }
+    if ("expressions" in node) {
+      node.expressions.forEach((x) => {
+        identifiers.push(...ASTUtils.getNestedIdentifiers(x));
+      });
+    }
+    if ("left" in node) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.left));
+    }
+    if ("right" in node) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.right));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.Property) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.value));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.SpreadElement) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.MemberExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.object));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.UnaryExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.ChainExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.expression));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.TSNonNullExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.expression));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.ArrowFunctionExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.body));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.FunctionExpression) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.body));
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.BlockStatement) {
+      identifiers.push(
+        ...node.body.map((body) => ASTUtils.getNestedIdentifiers(body)).flat()
+      );
+    }
+    if (node.type === import_utils.AST_NODE_TYPES.ReturnStatement && node.argument) {
+      identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+    }
+    return identifiers;
+  },
+  traverseUpOnly(identifier, allowedNodeTypes) {
+    const parent = identifier.parent;
+    if (parent !== void 0 && allowedNodeTypes.includes(parent.type)) {
+      return ASTUtils.traverseUpOnly(parent, allowedNodeTypes);
+    }
+    return identifier;
+  },
+  isDeclaredInNode(params) {
+    const { functionNode, reference, scopeManager } = params;
+    const scope = scopeManager.acquire(functionNode);
+    if (scope === null) {
+      return false;
+    }
+    return scope.set.has(reference.identifier.name);
+  },
+  getExternalRefs(params) {
+    const { scopeManager, sourceCode, node } = params;
+    const scope = scopeManager.acquire(node);
+    if (scope === null) {
+      return [];
+    }
+    const collectReferences = (currentScope) => {
+      const references2 = [...currentScope.references];
+      for (const childScope of currentScope.childScopes) {
+        references2.push(...collectReferences(childScope));
+      }
+      return references2;
+    };
+    const references = collectReferences(scope).filter((x) => x.isRead() && !scope.set.has(x.identifier.name)).map((x) => {
+      const referenceNode = ASTUtils.traverseUpOnly(x.identifier, [
+        import_utils.AST_NODE_TYPES.MemberExpression,
+        import_utils.AST_NODE_TYPES.Identifier
+      ]);
+      return {
+        variable: x,
+        node: referenceNode,
+        text: sourceCode.getText(referenceNode)
+      };
+    });
+    const localRefIds = new Set(
+      [...scope.set.values()].map((x) => sourceCode.getText(x.identifiers[0]))
+    );
+    const externalRefs = references.filter(
+      (x) => x.variable.resolved === null || !localRefIds.has(x.text)
+    );
+    return uniqueBy(externalRefs, (x) => x.text).map((x) => x.variable);
+  },
+  mapKeyNodeToText(node, sourceCode) {
+    return sourceCode.getText(
+      ASTUtils.traverseUpOnly(node, [
+        import_utils.AST_NODE_TYPES.MemberExpression,
+        import_utils.AST_NODE_TYPES.TSNonNullExpression,
+        import_utils.AST_NODE_TYPES.Identifier
+      ])
+    );
+  },
+  mapKeyNodeToBaseText(node, sourceCode) {
+    return ASTUtils.mapKeyNodeToText(node, sourceCode).replace(
+      /(?:\?(\.)|!)/g,
+      "$1"
+    );
+  },
+  isValidReactComponentOrHookName(identifier) {
+    return identifier !== null && identifier !== void 0 && /^(use|[A-Z])/.test(identifier.name);
+  },
+  getFunctionAncestor(sourceCode, node) {
+    for (const ancestor of sourceCode.getAncestors(node)) {
+      if (ASTUtils.isNodeOfOneOf(ancestor, [
+        import_utils.AST_NODE_TYPES.FunctionDeclaration,
+        import_utils.AST_NODE_TYPES.FunctionExpression,
+        import_utils.AST_NODE_TYPES.ArrowFunctionExpression
+      ])) {
+        return ancestor;
+      }
+      if (ancestor.parent?.type === import_utils.AST_NODE_TYPES.VariableDeclarator && ancestor.parent.id.type === import_utils.AST_NODE_TYPES.Identifier && ASTUtils.isNodeOfOneOf(ancestor, [
+        import_utils.AST_NODE_TYPES.FunctionDeclaration,
+        import_utils.AST_NODE_TYPES.FunctionExpression,
+        import_utils.AST_NODE_TYPES.ArrowFunctionExpression
+      ])) {
+        return ancestor;
+      }
+    }
+    return void 0;
+  },
+  getReferencedExpressionByIdentifier(params) {
+    const { node, context } = params;
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const scope = context.sourceCode.getScope(node) ? sourceCode.getScope(node) : context.getScope();
+    const resolvedNode = scope.references.find((ref) => ref.identifier === node)?.resolved?.defs[0]?.node;
+    if (resolvedNode?.type !== import_utils.AST_NODE_TYPES.VariableDeclarator) {
+      return null;
+    }
+    return resolvedNode.init;
+  },
+  getClosestVariableDeclarator(node) {
+    let currentNode = node;
+    while (currentNode.type !== import_utils.AST_NODE_TYPES.Program) {
+      if (currentNode.type === import_utils.AST_NODE_TYPES.VariableDeclarator) {
+        return currentNode;
+      }
+      currentNode = currentNode.parent;
+    }
+    return void 0;
+  },
+  getNestedReturnStatements(node) {
+    const returnStatements = [];
+    if (node.type === import_utils.AST_NODE_TYPES.ReturnStatement) {
+      returnStatements.push(node);
+    }
+    if ("body" in node && node.body !== void 0 && node.body !== null) {
+      Array.isArray(node.body) ? node.body.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      }) : returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.body)
+      );
+    }
+    if ("consequent" in node) {
+      Array.isArray(node.consequent) ? node.consequent.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      }) : returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.consequent)
+      );
+    }
+    if ("alternate" in node && node.alternate !== null) {
+      Array.isArray(node.alternate) ? node.alternate.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      }) : returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.alternate)
+      );
+    }
+    if ("cases" in node) {
+      node.cases.forEach((x) => {
+        returnStatements.push(...ASTUtils.getNestedReturnStatements(x));
+      });
+    }
+    if ("block" in node) {
+      returnStatements.push(...ASTUtils.getNestedReturnStatements(node.block));
+    }
+    if ("handler" in node && node.handler !== null) {
+      returnStatements.push(...ASTUtils.getNestedReturnStatements(node.handler));
+    }
+    if ("finalizer" in node && node.finalizer !== null) {
+      returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.finalizer)
+      );
+    }
+    if ("expression" in node && node.expression !== true && node.expression !== false) {
+      returnStatements.push(
+        ...ASTUtils.getNestedReturnStatements(node.expression)
+      );
+    }
+    if ("test" in node && node.test !== null) {
+      returnStatements.push(...ASTUtils.getNestedReturnStatements(node.test));
+    }
+    return returnStatements;
+  }
+};
+
+// src/utils/get-docs-url.ts
+var getDocsUrl = (ruleName) => `https://tanstack.com/query/latest/docs/eslint/${ruleName}`;
+
+// src/utils/detect-react-query-imports.ts
+var import_utils2 = require("@typescript-eslint/utils");
+function detectTanstackQueryImports(create) {
+  return (context, optionsWithDefault) => {
+    const tanstackQueryImportSpecifiers = [];
+    const helpers = {
+      isSpecificTanstackQueryImport(node, source) {
+        return !!tanstackQueryImportSpecifiers.find((specifier) => {
+          if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.parent.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportDeclaration && specifier.parent.source.value === source) {
+            return node.name === specifier.local.name;
+          }
+          return false;
+        });
+      },
+      isTanstackQueryImport(node) {
+        return !!tanstackQueryImportSpecifiers.find((specifier) => {
+          if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier) {
+            return node.name === specifier.local.name;
+          }
+          return false;
+        });
+      }
+    };
+    const detectionInstructions = {
+      ImportDeclaration(node) {
+        if (node.specifiers.length > 0 && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        (node.importKind === "value" || node.importKind === void 0) && node.source.value.startsWith("@tanstack/") && node.source.value.endsWith("-query")) {
+          tanstackQueryImportSpecifiers.push(...node.specifiers);
+        }
+      }
+    };
+    const ruleInstructions = create(context, optionsWithDefault, helpers);
+    const enhancedRuleInstructions = {};
+    const allKeys = new Set(
+      Object.keys(detectionInstructions).concat(Object.keys(ruleInstructions))
+    );
+    allKeys.forEach((instruction) => {
+      enhancedRuleInstructions[instruction] = (node) => {
+        if (instruction in detectionInstructions) {
+          detectionInstructions[instruction]?.(node);
+        }
+        const ruleInstruction = ruleInstructions[instruction];
+        if (ruleInstruction) {
+          return ruleInstruction(node);
+        }
+        return void 0;
+      };
+    });
+    return enhancedRuleInstructions;
+  };
+}
+
+// src/rules/exhaustive-deps/exhaustive-deps.utils.ts
+var import_utils3 = require("@typescript-eslint/utils");
+var ExhaustiveDepsUtils = {
+  isRelevantReference(params) {
+    const { sourceCode, reference, scopeManager, node, filename } = params;
+    const component = ASTUtils.getFunctionAncestor(sourceCode, node);
+    const queryFnScope = scopeManager.acquire(node);
+    if (queryFnScope === null || reference.isValueReference === false) {
+      return false;
+    }
+    let currentScope = reference.resolved?.scope ?? null;
+    while (currentScope !== null) {
+      if (currentScope === queryFnScope) {
+        return false;
+      }
+      currentScope = currentScope.upper;
+    }
+    if (component !== void 0) {
+      if (!ASTUtils.isDeclaredInNode({
+        scopeManager,
+        reference,
+        functionNode: component
+      })) {
+        return false;
+      }
+    } else {
+      const isVueFile = filename.endsWith(".vue");
+      if (!isVueFile) {
+        return false;
+      }
+      const definition = reference.resolved?.defs[0];
+      const isGlobalVariable = definition === void 0;
+      const isImport = definition?.type === "ImportBinding";
+      if (isGlobalVariable || isImport) {
+        return false;
+      }
+    }
+    return reference.identifier.name !== "undefined" && reference.identifier.parent.type !== import_utils3.AST_NODE_TYPES.NewExpression && !ExhaustiveDepsUtils.isInstanceOfKind(reference.identifier.parent);
+  },
+  /**
+   * Given required refs and existing queryKey entries, compute missing dependency paths
+   * respecting allowlisted variables and types.
+   */
+  computeFilteredMissingPaths(params) {
+    const {
+      requiredRefs,
+      allowlistedVariables,
+      existingRootIdentifiers,
+      existingFullPaths
+    } = params;
+    const missingPaths = /* @__PURE__ */ new Set();
+    for (const { root, path, allowlistedByType } of requiredRefs) {
+      if (existingRootIdentifiers.has(root)) continue;
+      if (allowlistedVariables.has(root)) continue;
+      if (existingFullPaths.has(path)) continue;
+      if (allowlistedByType) continue;
+      missingPaths.add(path);
+    }
+    for (const path of missingPaths) {
+      const root = path.split(".")[0];
+      if (root !== path && root !== void 0 && missingPaths.has(root)) {
+        missingPaths.delete(path);
+      }
+    }
+    return Array.from(missingPaths);
+  },
+  /**
+   * Extract existing queryKey deps as root identifiers and full member paths.
+   */
+  collectQueryKeyDeps(params) {
+    const { sourceCode, scopeManager, queryKeyNode } = params;
+    const roots = /* @__PURE__ */ new Set();
+    const paths = /* @__PURE__ */ new Set();
+    const visitorKeys = sourceCode.visitorKeys;
+    function addRoot(name8) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(name8);
+      roots.add(cleaned);
+      paths.add(cleaned);
+    }
+    function addFull(text) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(text);
+      paths.add(cleaned);
+    }
+    function addRefPath(refPath) {
+      if (!refPath) return;
+      if (refPath.coversRootMembers) {
+        addRoot(refPath.root);
+        return;
+      }
+      addFull(refPath.path);
+    }
+    function visitChildren(node) {
+      const keys = visitorKeys[node.type] ?? [];
+      for (const key of keys) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            if (ExhaustiveDepsUtils.isNode(item)) {
+              visit(item);
+            }
+          }
+          continue;
+        }
+        if (ExhaustiveDepsUtils.isNode(value)) {
+          visit(value);
+        }
+      }
+    }
+    function visit(node) {
+      if (!node) return;
+      switch (node.type) {
+        case import_utils3.AST_NODE_TYPES.Identifier: {
+          addRefPath(
+            ExhaustiveDepsUtils.computeRefPath({
+              identifier: node,
+              sourceCode
+            })
+          );
+          return;
+        }
+        case import_utils3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case import_utils3.AST_NODE_TYPES.FunctionExpression:
+          for (const reference of ExhaustiveDepsUtils.collectExternalRefsInFunction(
+            {
+              functionNode: node,
+              scopeManager
+            }
+          )) {
+            if (reference.identifier.type !== import_utils3.AST_NODE_TYPES.Identifier) {
+              continue;
+            }
+            addRefPath(
+              ExhaustiveDepsUtils.computeRefPath({
+                identifier: reference.identifier,
+                sourceCode
+              })
+            );
+          }
+          return;
+        case import_utils3.AST_NODE_TYPES.Property:
+          visit(node.value);
+          return;
+        case import_utils3.AST_NODE_TYPES.MemberExpression:
+          if (node.parent.type === import_utils3.AST_NODE_TYPES.CallExpression && node.parent.callee === node && node.object.type === import_utils3.AST_NODE_TYPES.Identifier) {
+            addRoot(node.object.name);
+          } else {
+            visit(node.object);
+          }
+          return;
+        case import_utils3.AST_NODE_TYPES.CallExpression:
+          node.arguments.forEach((argument) => visit(argument));
+          switch (node.callee.type) {
+            case import_utils3.AST_NODE_TYPES.Identifier:
+            case import_utils3.AST_NODE_TYPES.MemberExpression:
+            case import_utils3.AST_NODE_TYPES.ChainExpression:
+            case import_utils3.AST_NODE_TYPES.TSNonNullExpression:
+              visit(node.callee);
+              break;
+          }
+          return;
+      }
+      visitChildren(node);
+    }
+    visit(queryKeyNode);
+    return { roots, paths };
+  },
+  isNode(value) {
+    return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+  },
+  /**
+   * Checks whether the resolved variable is allowlisted by its type annotation
+   */
+  variableIsAllowlistedByType(params) {
+    const { allowlistedTypes, variable } = params;
+    if (allowlistedTypes.size === 0) return false;
+    if (!variable) return false;
+    for (const id of variable.identifiers) {
+      if (id.typeAnnotation) {
+        const typeIdentifiers = /* @__PURE__ */ new Set();
+        ExhaustiveDepsUtils.collectTypeIdentifiers(
+          id.typeAnnotation.typeAnnotation,
+          typeIdentifiers
+        );
+        for (const typeIdentifier of typeIdentifiers) {
+          if (allowlistedTypes.has(typeIdentifier)) return true;
+        }
+      }
+    }
+    return false;
+  },
+  isInstanceOfKind(node) {
+    return node.type === import_utils3.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof";
+  },
+  /**
+   * Normalizes a chain by removing optional chaining operators
+   *
+   * Example: `a?.b.c!` -> `a.b.c`
+   */
+  normalizeChain(text) {
+    return text.replace(/(?:\?(\.)|!)/g, "$1");
+  },
+  /**
+   * Computes the reference path for an identifier
+   *
+   * Example: `a.b.c!` -> `{ path: 'a.b.c', root: 'a' }`
+   */
+  computeRefPath(params) {
+    const { identifier, sourceCode } = params;
+    const fullChainNode = ASTUtils.traverseUpOnly(identifier, [
+      import_utils3.AST_NODE_TYPES.MemberExpression,
+      import_utils3.AST_NODE_TYPES.TSNonNullExpression,
+      import_utils3.AST_NODE_TYPES.Identifier
+    ]);
+    const fullText = ExhaustiveDepsUtils.normalizeChain(
+      sourceCode.getText(fullChainNode)
+    );
+    const parent = fullChainNode.parent;
+    let dependencyPath = fullText;
+    let coversRootMembers = fullText === identifier.name;
+    if (parent && parent.type === import_utils3.AST_NODE_TYPES.CallExpression && parent.callee === fullChainNode) {
+      const segments = fullText.split(".");
+      if (segments.length > 1) {
+        dependencyPath = segments.slice(0, -1).join(".");
+      }
+      coversRootMembers = false;
+    }
+    dependencyPath = dependencyPath.split(".")[0] === "" ? identifier.name : dependencyPath;
+    const root = dependencyPath.split(".")[0];
+    return {
+      path: dependencyPath,
+      root: root ?? identifier.name,
+      coversRootMembers: coversRootMembers && dependencyPath === root
+    };
+  },
+  collectExternalRefsInFunction(params) {
+    const { functionNode, scopeManager } = params;
+    const functionScope = scopeManager.acquire(functionNode);
+    if (functionScope === null) {
+      return [];
+    }
+    const externalRefs = [];
+    function collect(scope) {
+      for (const reference of scope.references) {
+        if (!reference.isRead() || reference.resolved === null) {
+          continue;
+        }
+        let currentScope = reference.resolved.scope;
+        let declaredInsideFunction = false;
+        while (currentScope !== null) {
+          if (currentScope === functionScope) {
+            declaredInsideFunction = true;
+            break;
+          }
+          currentScope = currentScope.upper;
+        }
+        if (!declaredInsideFunction) {
+          externalRefs.push(reference);
+        }
+      }
+      for (const childScope of scope.childScopes) {
+        collect(childScope);
+      }
+    }
+    collect(functionScope);
+    return externalRefs;
+  },
+  /**
+   * Recursively collects type identifiers from a type annotation
+   */
+  collectTypeIdentifiers(typeNode, out) {
+    switch (typeNode.type) {
+      case import_utils3.AST_NODE_TYPES.TSTypeReference: {
+        if (typeNode.typeName.type === import_utils3.AST_NODE_TYPES.Identifier) {
+          out.add(typeNode.typeName.name);
+        }
+        break;
+      }
+      case import_utils3.AST_NODE_TYPES.TSUnionType:
+      case import_utils3.AST_NODE_TYPES.TSIntersectionType: {
+        typeNode.types.forEach(
+          (t) => ExhaustiveDepsUtils.collectTypeIdentifiers(t, out)
+        );
+        break;
+      }
+      case import_utils3.AST_NODE_TYPES.TSArrayType: {
+        ExhaustiveDepsUtils.collectTypeIdentifiers(typeNode.elementType, out);
+        break;
+      }
+      case import_utils3.AST_NODE_TYPES.TSTupleType: {
+        typeNode.elementTypes.forEach(
+          (et) => ExhaustiveDepsUtils.collectTypeIdentifiers(et, out)
+        );
+        break;
+      }
+    }
+  },
+  /**
+   * Gets the function expression nodes from a queryFn property, handling conditional expressions.
+   * When neither branch is skipToken, returns both branches so all deps are scanned.
+   */
+  getQueryFnNodes(queryFn) {
+    if (queryFn.value.type !== import_utils3.AST_NODE_TYPES.ConditionalExpression) {
+      return [queryFn.value];
+    }
+    if (queryFn.value.consequent.type === import_utils3.AST_NODE_TYPES.Identifier && queryFn.value.consequent.name === "skipToken") {
+      return [queryFn.value.alternate];
+    }
+    if (queryFn.value.alternate.type === import_utils3.AST_NODE_TYPES.Identifier && queryFn.value.alternate.name === "skipToken") {
+      return [queryFn.value.consequent];
+    }
+    return [queryFn.value.consequent, queryFn.value.alternate];
+  }
+};
+
+// src/rules/exhaustive-deps/exhaustive-deps.rule.ts
+var QUERY_KEY = "queryKey";
+var QUERY_FN = "queryFn";
+var name = "exhaustive-deps";
+var createRule = import_utils4.ESLintUtils.RuleCreator(getDocsUrl);
+var rule = createRule({
+  name,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Exhaustive deps rule for useQuery",
+      recommended: "error"
+    },
+    messages: {
+      missingDeps: `The following dependencies are missing in your queryKey: {{deps}}`,
+      fixTo: "Fix to {{result}}"
+    },
+    hasSuggestions: true,
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowlist: {
+            type: "object",
+            properties: {
+              variables: { type: "array", items: { type: "string" } },
+              types: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context) => {
+    return {
+      ObjectExpression: (node) => {
+        const scopeManager = context.sourceCode.scopeManager;
+        const queryKey = ASTUtils.findPropertyWithIdentifierKey(
+          node.properties,
+          QUERY_KEY
+        );
+        const queryFn = ASTUtils.findPropertyWithIdentifierKey(
+          node.properties,
+          QUERY_FN
+        );
+        if (scopeManager === null || queryKey === void 0 || queryFn === void 0 || !ASTUtils.isNodeOfOneOf(queryFn.value, [
+          import_utils4.AST_NODE_TYPES.ArrowFunctionExpression,
+          import_utils4.AST_NODE_TYPES.FunctionExpression,
+          import_utils4.AST_NODE_TYPES.ConditionalExpression
+        ])) {
+          return;
+        }
+        const queryKeyNode = dereferenceVariablesAndTypeAssertions(
+          queryKey.value,
+          context
+        );
+        const queryFnNodes = ExhaustiveDepsUtils.getQueryFnNodes(queryFn);
+        const externalRefs = queryFnNodes.flatMap(
+          (fnNode) => ASTUtils.getExternalRefs({
+            scopeManager,
+            sourceCode: context.sourceCode,
+            node: fnNode
+          })
+        );
+        const relevantRefs = externalRefs.filter(
+          (reference) => queryFnNodes.some(
+            (fnNode) => ExhaustiveDepsUtils.isRelevantReference({
+              sourceCode: context.sourceCode,
+              reference,
+              scopeManager,
+              node: fnNode,
+              filename: context.filename
+            })
+          )
+        );
+        const ruleOptions = context.options.at(0);
+        const allowlistedVariables = new Set(
+          ruleOptions?.allowlist?.variables ?? []
+        );
+        const allowlistedTypes = new Set(ruleOptions?.allowlist?.types ?? []);
+        const requiredRefs = relevantRefs.flatMap((ref) => {
+          if (ref.identifier.type !== import_utils4.AST_NODE_TYPES.Identifier) return [];
+          const refPath = ExhaustiveDepsUtils.computeRefPath({
+            identifier: ref.identifier,
+            sourceCode: context.sourceCode
+          });
+          if (refPath === null) return [];
+          return [
+            {
+              ...refPath,
+              allowlistedByType: ExhaustiveDepsUtils.variableIsAllowlistedByType({
+                allowlistedTypes,
+                variable: ref.resolved ?? null
+              })
+            }
+          ];
+        });
+        if (requiredRefs.length === 0) return;
+        const queryKeyDeps = ExhaustiveDepsUtils.collectQueryKeyDeps({
+          sourceCode: context.sourceCode,
+          scopeManager,
+          queryKeyNode
+        });
+        const missingPaths = ExhaustiveDepsUtils.computeFilteredMissingPaths({
+          requiredRefs,
+          allowlistedVariables,
+          existingRootIdentifiers: queryKeyDeps.roots,
+          existingFullPaths: queryKeyDeps.paths
+        });
+        if (missingPaths.length === 0) return;
+        const missingAsText = missingPaths.join(", ");
+        const suggestions = buildSuggestions({
+          queryKeyNode,
+          missingPaths,
+          missingAsText,
+          sourceCode: context.sourceCode
+        });
+        context.report({
+          node,
+          messageId: "missingDeps",
+          data: { deps: missingAsText },
+          suggest: suggestions
+        });
+      }
+    };
+  })
+});
+function buildSuggestions(params) {
+  const { queryKeyNode, missingPaths, missingAsText, sourceCode } = params;
+  if (queryKeyNode.type !== import_utils4.AST_NODE_TYPES.ArrayExpression) {
+    return [];
+  }
+  const closingBracket = sourceCode.getLastToken(queryKeyNode);
+  if (!closingBracket) return [];
+  const existingElements = queryKeyNode.elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
+  const resultText = `[${[...existingElements, ...missingPaths].join(", ")}]`;
+  if (queryKeyNode.elements.length === 0) {
+    return [
+      {
+        messageId: "fixTo",
+        data: { result: resultText },
+        fix: (fixer) => fixer.replaceText(queryKeyNode, resultText)
+      }
+    ];
+  }
+  const tokenBefore = sourceCode.getTokenBefore(closingBracket);
+  const separator = tokenBefore?.value === "," ? " " : ", ";
+  return [
+    {
+      messageId: "fixTo",
+      data: { result: resultText },
+      fix: (fixer) => fixer.insertTextBefore(closingBracket, `${separator}${missingAsText}`)
+    }
+  ];
+}
+function dereferenceVariablesAndTypeAssertions(queryKeyNode, context) {
+  const visitedNodes = /* @__PURE__ */ new Set();
+  for (let i = 0; i < 1 << 8; ++i) {
+    if (visitedNodes.has(queryKeyNode)) {
+      return queryKeyNode;
+    }
+    visitedNodes.add(queryKeyNode);
+    switch (queryKeyNode.type) {
+      case import_utils4.AST_NODE_TYPES.TSAsExpression:
+        queryKeyNode = queryKeyNode.expression;
+        break;
+      case import_utils4.AST_NODE_TYPES.Identifier: {
+        const expression = ASTUtils.getReferencedExpressionByIdentifier({
+          context,
+          node: queryKeyNode
+        });
+        if (expression == null) {
+          return queryKeyNode;
+        }
+        queryKeyNode = expression;
+        break;
+      }
+      default:
+        return queryKeyNode;
+    }
+  }
+  return queryKeyNode;
+}
+
+// src/rules/stable-query-client/stable-query-client.rule.ts
+var import_utils5 = require("@typescript-eslint/utils");
+var name2 = "stable-query-client";
+var createRule2 = import_utils5.ESLintUtils.RuleCreator(getDocsUrl);
+var rule2 = createRule2({
+  name: name2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Makes sure that QueryClient is stable",
+      recommended: "error"
+    },
+    messages: {
+      unstable: [
+        "QueryClient is not stable. It should be either extracted from the component or wrapped in React.useState.",
+        "See https://tkdodo.eu/blog/react-query-fa-qs#2-the-queryclient-is-not-stable"
+      ].join("\n"),
+      fixTo: "Fix to {{result}}"
+    },
+    hasSuggestions: true,
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context, _, helpers) => {
+    return {
+      NewExpression: (node) => {
+        if (node.callee.type !== import_utils5.AST_NODE_TYPES.Identifier || node.callee.name !== "QueryClient" || node.parent.type !== import_utils5.AST_NODE_TYPES.VariableDeclarator || !helpers.isSpecificTanstackQueryImport(
+          node.callee,
+          "@tanstack/react-query"
+        )) {
+          return;
+        }
+        const fnAncestor = ASTUtils.getFunctionAncestor(
+          context.sourceCode,
+          node
+        );
+        const isReactServerComponent = fnAncestor?.async === true;
+        if (!ASTUtils.isValidReactComponentOrHookName(fnAncestor?.id) || isReactServerComponent) {
+          return;
+        }
+        context.report({
+          node: node.parent,
+          messageId: "unstable",
+          fix: (() => {
+            const { parent } = node;
+            if (parent.id.type !== import_utils5.AST_NODE_TYPES.Identifier) {
+              return;
+            }
+            const sourceCode = context.sourceCode ?? context.getSourceCode();
+            const nodeText = sourceCode.getText(node);
+            const variableName = parent.id.name;
+            return (fixer) => {
+              return fixer.replaceTextRange(
+                [parent.range[0], parent.range[1]],
+                `[${variableName}] = React.useState(() => ${nodeText})`
+              );
+            };
+          })()
+        });
+      }
+    };
+  })
+});
+
+// src/rules/no-rest-destructuring/no-rest-destructuring.rule.ts
+var import_utils7 = require("@typescript-eslint/utils");
+
+// src/rules/no-rest-destructuring/no-rest-destructuring.utils.ts
+var import_utils6 = require("@typescript-eslint/utils");
+var NoRestDestructuringUtils = {
+  isObjectRestDestructuring(node) {
+    if (node.type !== import_utils6.AST_NODE_TYPES.ObjectPattern) {
+      return false;
+    }
+    return node.properties.some((p) => p.type === import_utils6.AST_NODE_TYPES.RestElement);
+  }
+};
+
+// src/rules/no-rest-destructuring/no-rest-destructuring.rule.ts
+var name3 = "no-rest-destructuring";
+var queryHooks = [
+  "useQuery",
+  "useQueries",
+  "useInfiniteQuery",
+  "useSuspenseQuery",
+  "useSuspenseQueries",
+  "useSuspenseInfiniteQuery"
+];
+var createRule3 = import_utils7.ESLintUtils.RuleCreator(getDocsUrl);
+var rule3 = createRule3({
+  name: name3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallows rest destructuring in queries",
+      recommended: "warn"
+    },
+    messages: {
+      objectRestDestructure: `Object rest destructuring on a query will observe all changes to the query, leading to excessive re-renders.`
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context, _, helpers) => {
+    const queryResultVariables = /* @__PURE__ */ new Set();
+    return {
+      CallExpression: (node) => {
+        if (!ASTUtils.isIdentifierWithOneOfNames(node.callee, queryHooks) || node.parent.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator || !helpers.isTanstackQueryImport(node.callee)) {
+          return;
+        }
+        const returnValue = node.parent.id;
+        if (node.callee.name !== "useQueries" && node.callee.name !== "useSuspenseQueries") {
+          if (NoRestDestructuringUtils.isObjectRestDestructuring(returnValue)) {
+            return context.report({
+              node: node.parent,
+              messageId: "objectRestDestructure"
+            });
+          }
+          if (returnValue.type === import_utils7.AST_NODE_TYPES.Identifier) {
+            queryResultVariables.add(returnValue.name);
+          }
+          return;
+        }
+        if (returnValue.type !== import_utils7.AST_NODE_TYPES.ArrayPattern) {
+          if (returnValue.type === import_utils7.AST_NODE_TYPES.Identifier) {
+            queryResultVariables.add(returnValue.name);
+          }
+          return;
+        }
+        returnValue.elements.forEach((queryResult) => {
+          if (queryResult === null) {
+            return;
+          }
+          if (NoRestDestructuringUtils.isObjectRestDestructuring(queryResult)) {
+            context.report({
+              node: queryResult,
+              messageId: "objectRestDestructure"
+            });
+          }
+        });
+      },
+      VariableDeclarator: (node) => {
+        if (node.init?.type === import_utils7.AST_NODE_TYPES.Identifier && queryResultVariables.has(node.init.name) && NoRestDestructuringUtils.isObjectRestDestructuring(node.id)) {
+          context.report({
+            node,
+            messageId: "objectRestDestructure"
+          });
+        }
+      },
+      SpreadElement: (node) => {
+        if (node.argument.type === import_utils7.AST_NODE_TYPES.Identifier && queryResultVariables.has(node.argument.name)) {
+          context.report({
+            node,
+            messageId: "objectRestDestructure"
+          });
+        }
+      }
+    };
+  })
+});
+
+// src/rules/no-unstable-deps/no-unstable-deps.rule.ts
+var import_utils8 = require("@typescript-eslint/utils");
+var name4 = "no-unstable-deps";
+var reactHookNames = ["useEffect", "useCallback", "useMemo"];
+var useQueryHookNames = [
+  "useQuery",
+  "useSuspenseQuery",
+  "useQueries",
+  "useSuspenseQueries",
+  "useInfiniteQuery",
+  "useSuspenseInfiniteQuery"
+];
+var allHookNames = ["useMutation", ...useQueryHookNames];
+var createRule4 = import_utils8.ESLintUtils.RuleCreator(getDocsUrl);
+var rule4 = createRule4({
+  name: name4,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow putting the result of query hooks directly in a React hook dependency array",
+      recommended: "error"
+    },
+    messages: {
+      noUnstableDeps: `The result of {{queryHook}} is not referentially stable, so don't pass it directly into the dependencies array of {{reactHook}}. Instead, destructure the return value of {{queryHook}} and pass the destructured values into the dependency array of {{reactHook}}.`
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context, _options, helpers) => {
+    const trackedVariables = {};
+    const hookAliasMap = {};
+    function getReactHook(node) {
+      if (node.callee.type === "Identifier") {
+        const calleeName = node.callee.name;
+        if (reactHookNames.includes(calleeName) || calleeName in hookAliasMap) {
+          return calleeName;
+        }
+      } else if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "React" && node.callee.property.type === "Identifier" && reactHookNames.includes(node.callee.property.name)) {
+        return node.callee.property.name;
+      }
+      return void 0;
+    }
+    function collectVariableNames(pattern, queryHook) {
+      if (pattern.type === import_utils8.AST_NODE_TYPES.Identifier) {
+        trackedVariables[pattern.name] = queryHook;
+      }
+    }
+    function hasCombineProperty(callExpression) {
+      if (callExpression.arguments.length === 0) return false;
+      const firstArg = callExpression.arguments[0];
+      if (!firstArg || firstArg.type !== import_utils8.AST_NODE_TYPES.ObjectExpression)
+        return false;
+      return firstArg.properties.some(
+        (prop) => prop.type === import_utils8.AST_NODE_TYPES.Property && prop.key.type === import_utils8.AST_NODE_TYPES.Identifier && prop.key.name === "combine"
+      );
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.specifiers.length > 0 && node.importKind === "value" && node.source.value === "React") {
+          node.specifiers.forEach((specifier) => {
+            if (specifier.type === import_utils8.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils8.AST_NODE_TYPES.Identifier && reactHookNames.includes(specifier.imported.name)) {
+              hookAliasMap[specifier.local.name] = specifier.imported.name;
+            }
+          });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.init !== null && node.init.type === import_utils8.AST_NODE_TYPES.CallExpression && node.init.callee.type === import_utils8.AST_NODE_TYPES.Identifier && allHookNames.includes(node.init.callee.name) && helpers.isTanstackQueryImport(node.init.callee)) {
+          if (node.init.callee.name === "useQueries" && hasCombineProperty(node.init)) {
+            return;
+          }
+          collectVariableNames(node.id, node.init.callee.name);
+        }
+      },
+      CallExpression: (node) => {
+        const reactHook = getReactHook(node);
+        if (reactHook !== void 0 && node.arguments.length > 1 && node.arguments[1]?.type === import_utils8.AST_NODE_TYPES.ArrayExpression) {
+          const depsArray = node.arguments[1].elements;
+          depsArray.forEach((dep) => {
+            if (dep !== null && dep.type === import_utils8.AST_NODE_TYPES.Identifier && trackedVariables[dep.name] !== void 0) {
+              const queryHook = trackedVariables[dep.name];
+              context.report({
+                node: dep,
+                messageId: "noUnstableDeps",
+                data: {
+                  queryHook,
+                  reactHook
+                }
+              });
+            }
+          });
+        }
+      }
+    };
+  })
+});
+
+// src/utils/create-property-order-rule.ts
+var import_utils9 = require("@typescript-eslint/utils");
+
+// src/utils/sort-data-by-order.ts
+function sortDataByOrder(data, orderRules, key) {
+  const getSubsetIndex = (item, subsets) => {
+    for (let i = 0; i < subsets.length; i++) {
+      if (subsets[i]?.includes(item)) {
+        return i;
+      }
+    }
+    return null;
+  };
+  const orderSets = orderRules.reduce(
+    (sets, [A, B]) => [...sets, A, B],
+    []
+  );
+  const inOrderArray = data.filter(
+    (item) => getSubsetIndex(item[key], orderSets) !== null
+  );
+  let wasResorted = false;
+  const sortedArray = inOrderArray.sort((a, b) => {
+    const aKey = a[key], bKey = b[key];
+    const aSubsetIndex = getSubsetIndex(aKey, orderSets);
+    const bSubsetIndex = getSubsetIndex(bKey, orderSets);
+    if (aSubsetIndex !== null && bSubsetIndex !== null && aSubsetIndex !== bSubsetIndex) {
+      return aSubsetIndex - bSubsetIndex;
+    }
+    return 0;
+  });
+  const inOrderIterator = sortedArray.values();
+  const result = data.map((item) => {
+    if (getSubsetIndex(item[key], orderSets) !== null) {
+      const sortedItem = inOrderIterator.next().value;
+      if (sortedItem[key] !== item[key]) {
+        wasResorted = true;
+      }
+      return sortedItem;
+    }
+    return item;
+  });
+  if (!wasResorted) {
+    return null;
+  }
+  return result;
+}
+
+// src/utils/create-property-order-rule.ts
+var createRule5 = import_utils9.ESLintUtils.RuleCreator(getDocsUrl);
+function createPropertyOrderRule(options, targetFunctions, orderRules) {
+  const targetFunctionSet = new Set(targetFunctions);
+  function isTargetFunction(node) {
+    return targetFunctionSet.has(node);
+  }
+  return createRule5({
+    ...options,
+    create: detectTanstackQueryImports((context) => {
+      return {
+        CallExpression(node) {
+          if (node.callee.type !== import_utils9.AST_NODE_TYPES.Identifier) {
+            return;
+          }
+          const functions = node.callee.name;
+          if (!isTargetFunction(functions)) {
+            return;
+          }
+          const argument = node.arguments[0];
+          if (argument === void 0 || argument.type !== "ObjectExpression") {
+            return;
+          }
+          const allProperties = argument.properties;
+          if (allProperties.length < 2) {
+            return;
+          }
+          const properties = allProperties.flatMap((p, index) => {
+            if (p.type === import_utils9.AST_NODE_TYPES.Property && p.key.type === import_utils9.AST_NODE_TYPES.Identifier) {
+              return { name: p.key.name, property: p };
+            } else return { name: `_property_${index}`, property: p };
+          });
+          const sortedProperties = sortDataByOrder(
+            properties,
+            orderRules,
+            "name"
+          );
+          if (sortedProperties === null) {
+            return;
+          }
+          context.report({
+            node: argument,
+            data: { function: node.callee.name },
+            messageId: "invalidOrder",
+            fix(fixer) {
+              const sourceCode = context.sourceCode;
+              const reorderedText = sortedProperties.reduce(
+                (sourceText, specifier, index) => {
+                  let textBetweenProperties = "";
+                  if (index < allProperties.length - 1) {
+                    textBetweenProperties = sourceCode.getText().slice(
+                      allProperties[index].range[1],
+                      allProperties[index + 1].range[0]
+                    );
+                  }
+                  return sourceText + sourceCode.getText(specifier.property) + textBetweenProperties;
+                },
+                ""
+              );
+              return fixer.replaceTextRange(
+                [allProperties[0].range[0], allProperties.at(-1).range[1]],
+                reorderedText
+              );
+            }
+          });
+        }
+      };
+    })
+  });
+}
+
+// src/rules/infinite-query-property-order/constants.ts
+var infiniteQueryFunctions = [
+  "infiniteQueryOptions",
+  "useInfiniteQuery",
+  "useSuspenseInfiniteQuery"
+];
+var sortRules = [
+  [["queryFn"], ["getPreviousPageParam", "getNextPageParam"]]
+];
+
+// src/rules/infinite-query-property-order/infinite-query-property-order.rule.ts
+var name5 = "infinite-query-property-order";
+var rule5 = createPropertyOrderRule(
+  {
+    name: name5,
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Ensure correct order of inference sensitive properties for infinite queries",
+        recommended: "error"
+      },
+      messages: {
+        invalidOrder: "Invalid order of properties for `{{function}}`."
+      },
+      schema: [],
+      hasSuggestions: true,
+      fixable: "code"
+    },
+    defaultOptions: []
+  },
+  infiniteQueryFunctions,
+  sortRules
+);
+
+// src/rules/no-void-query-fn/no-void-query-fn.rule.ts
+var import_utils10 = require("@typescript-eslint/utils");
+var TypeFlags = {
+  Void: 16384,
+  Undefined: 32768
+};
+var name6 = "no-void-query-fn";
+var createRule6 = import_utils10.ESLintUtils.RuleCreator(getDocsUrl);
+var rule6 = createRule6({
+  name: name6,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensures queryFn returns a non-undefined value",
+      recommended: "error"
+    },
+    messages: {
+      noVoidReturn: "queryFn must return a non-undefined value"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context) => {
+    return {
+      Property(node) {
+        if (!ASTUtils.isObjectExpression(node.parent) || !ASTUtils.isIdentifierWithName(node.key, "queryFn")) {
+          return;
+        }
+        const parserServices = context.sourceCode.parserServices;
+        if (!parserServices || !parserServices.esTreeNodeToTSNodeMap || !parserServices.program) {
+          return;
+        }
+        const checker = parserServices.program.getTypeChecker();
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.value);
+        const type = checker.getTypeAtLocation(tsNode);
+        if (type.getCallSignatures().length > 0) {
+          const returnType = type.getCallSignatures()[0]?.getReturnType();
+          if (!returnType) {
+            return;
+          }
+          if (isIllegalReturn(checker, returnType)) {
+            context.report({
+              node: node.value,
+              messageId: "noVoidReturn"
+            });
+          }
+        }
+      }
+    };
+  })
+});
+function isIllegalReturn(checker, type) {
+  const awaited = checker.getAwaitedType(type);
+  if (!awaited) return false;
+  if (awaited.isUnion()) {
+    return awaited.types.some((t) => isIllegalReturn(checker, t));
+  }
+  return awaited.flags & (TypeFlags.Void | TypeFlags.Undefined) ? true : false;
+}
+
+// src/rules/mutation-property-order/constants.ts
+var mutationFunctions = ["useMutation"];
+var sortRules2 = [[["onMutate"], ["onError", "onSettled"]]];
+
+// src/rules/mutation-property-order/mutation-property-order.rule.ts
+var name7 = "mutation-property-order";
+var rule7 = createPropertyOrderRule(
+  {
+    name: name7,
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Ensure correct order of inference-sensitive properties in useMutation()",
+        recommended: "error"
+      },
+      messages: {
+        invalidOrder: "Invalid order of properties for `{{function}}`."
+      },
+      schema: [],
+      hasSuggestions: true,
+      fixable: "code"
+    },
+    defaultOptions: []
+  },
+  mutationFunctions,
+  sortRules2
+);
+
+// src/rules.ts
+var rules = {
+  [name]: rule,
+  [name2]: rule2,
+  [name3]: rule3,
+  [name4]: rule4,
+  [name5]: rule5,
+  [name6]: rule6,
+  [name7]: rule7
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rules
+});
+module.exports = module.exports.default
+//# sourceMappingURL=rules.cjs.map