@icebreakers/eslint-config 4.0.10 → 5.0.0

package/dist/modern-DnYnDvqZ.js

@@ -0,0 +1,1141 @@
+import { AST_NODE_TYPES, ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+//#region ../../node_modules/.pnpm/@tanstack+eslint-plugin-query@5.100.10_eslint@10.3.0_jiti@2.7.0__typescript@6.0.3/node_modules/@tanstack/eslint-plugin-query/build/modern/chunk-CI2SSAE2.js
+function uniqueBy(arr, fn) {
+	return arr.filter((x, i, a) => a.findIndex((y) => fn(x) === fn(y)) === i);
+}
+var ASTUtils = {
+	isNodeOfOneOf(node, types) {
+		return types.includes(node.type);
+	},
+	isIdentifier(node) {
+		return node.type === AST_NODE_TYPES.Identifier;
+	},
+	isIdentifierWithName(node, name9) {
+		return ASTUtils.isIdentifier(node) && node.name === name9;
+	},
+	isIdentifierWithOneOfNames(node, name9) {
+		return ASTUtils.isIdentifier(node) && name9.includes(node.name);
+	},
+	isProperty(node) {
+		return node.type === AST_NODE_TYPES.Property;
+	},
+	isObjectExpression(node) {
+		return node.type === 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 === AST_NODE_TYPES.Property) identifiers.push(...ASTUtils.getNestedIdentifiers(node.value));
+		if (node.type === AST_NODE_TYPES.SpreadElement) identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+		if (node.type === AST_NODE_TYPES.MemberExpression) identifiers.push(...ASTUtils.getNestedIdentifiers(node.object));
+		if (node.type === AST_NODE_TYPES.UnaryExpression) identifiers.push(...ASTUtils.getNestedIdentifiers(node.argument));
+		if (node.type === AST_NODE_TYPES.ChainExpression) identifiers.push(...ASTUtils.getNestedIdentifiers(node.expression));
+		if (node.type === AST_NODE_TYPES.TSNonNullExpression) identifiers.push(...ASTUtils.getNestedIdentifiers(node.expression));
+		if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) identifiers.push(...ASTUtils.getNestedIdentifiers(node.body));
+		if (node.type === AST_NODE_TYPES.FunctionExpression) identifiers.push(...ASTUtils.getNestedIdentifiers(node.body));
+		if (node.type === AST_NODE_TYPES.BlockStatement) identifiers.push(...node.body.map((body) => ASTUtils.getNestedIdentifiers(body)).flat());
+		if (node.type === 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, [AST_NODE_TYPES.MemberExpression, 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])));
+		return uniqueBy(references.filter((x) => x.variable.resolved === null || !localRefIds.has(x.text)), (x) => x.text).map((x) => x.variable);
+	},
+	mapKeyNodeToText(node, sourceCode) {
+		return sourceCode.getText(ASTUtils.traverseUpOnly(node, [
+			AST_NODE_TYPES.MemberExpression,
+			AST_NODE_TYPES.TSNonNullExpression,
+			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, [
+				AST_NODE_TYPES.FunctionDeclaration,
+				AST_NODE_TYPES.FunctionExpression,
+				AST_NODE_TYPES.ArrowFunctionExpression
+			])) return ancestor;
+			if (ancestor.parent?.type === AST_NODE_TYPES.VariableDeclarator && ancestor.parent.id.type === AST_NODE_TYPES.Identifier && ASTUtils.isNodeOfOneOf(ancestor, [
+				AST_NODE_TYPES.FunctionDeclaration,
+				AST_NODE_TYPES.FunctionExpression,
+				AST_NODE_TYPES.ArrowFunctionExpression
+			])) return ancestor;
+		}
+	},
+	getReferencedExpressionByIdentifier(params) {
+		const { node, context } = params;
+		const sourceCode = context.sourceCode ?? context.getSourceCode();
+		const resolvedNode = (context.sourceCode.getScope(node) ? sourceCode.getScope(node) : context.getScope()).references.find((ref) => ref.identifier === node)?.resolved?.defs[0]?.node;
+		if (resolvedNode?.type !== AST_NODE_TYPES.VariableDeclarator) return null;
+		return resolvedNode.init;
+	},
+	getClosestVariableDeclarator(node) {
+		let currentNode = node;
+		while (currentNode.type !== AST_NODE_TYPES.Program) {
+			if (currentNode.type === AST_NODE_TYPES.VariableDeclarator) return currentNode;
+			currentNode = currentNode.parent;
+		}
+	},
+	getNestedReturnStatements(node) {
+		const returnStatements = [];
+		if (node.type === 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;
+	}
+};
+var getDocsUrl = (ruleName) => `https://tanstack.com/query/latest/docs/eslint/${ruleName}`;
+function detectTanstackQueryImports(create) {
+	return (context, optionsWithDefault) => {
+		const tanstackQueryImportSpecifiers = [];
+		const helpers = {
+			isSpecificTanstackQueryImport(node, source) {
+				return !!tanstackQueryImportSpecifiers.find((specifier) => {
+					if (specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.parent.type === 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 === TSESTree.AST_NODE_TYPES.ImportSpecifier) return node.name === specifier.local.name;
+					return false;
+				});
+			}
+		};
+		const detectionInstructions = { ImportDeclaration(node) {
+			if (node.specifiers.length > 0 && (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 = {};
+		new Set(Object.keys(detectionInstructions).concat(Object.keys(ruleInstructions))).forEach((instruction) => {
+			enhancedRuleInstructions[instruction] = (node) => {
+				if (instruction in detectionInstructions) detectionInstructions[instruction]?.(node);
+				const ruleInstruction = ruleInstructions[instruction];
+				if (ruleInstruction) return ruleInstruction(node);
+			};
+		});
+		return enhancedRuleInstructions;
+	};
+}
+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 {
+			if (!filename.endsWith(".vue")) 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 !== 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(name9) {
+			const cleaned = ExhaustiveDepsUtils.normalizeChain(name9);
+			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 AST_NODE_TYPES.Identifier:
+					addRefPath(ExhaustiveDepsUtils.computeRefPath({
+						identifier: node,
+						sourceCode
+					}));
+					return;
+				case AST_NODE_TYPES.ArrowFunctionExpression:
+				case AST_NODE_TYPES.FunctionExpression:
+					for (const reference of ExhaustiveDepsUtils.collectExternalRefsInFunction({
+						functionNode: node,
+						scopeManager
+					})) {
+						if (reference.identifier.type !== AST_NODE_TYPES.Identifier) continue;
+						addRefPath(ExhaustiveDepsUtils.computeRefPath({
+							identifier: reference.identifier,
+							sourceCode
+						}));
+					}
+					return;
+				case AST_NODE_TYPES.Property:
+					visit(node.value);
+					return;
+				case AST_NODE_TYPES.MemberExpression:
+					if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node && node.object.type === AST_NODE_TYPES.Identifier) addRoot(node.object.name);
+					else visit(node.object);
+					return;
+				case AST_NODE_TYPES.CallExpression:
+					node.arguments.forEach((argument) => visit(argument));
+					switch (node.callee.type) {
+						case AST_NODE_TYPES.Identifier:
+						case AST_NODE_TYPES.MemberExpression:
+						case AST_NODE_TYPES.ChainExpression:
+						case 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 === 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").replace(/\s+/g, "");
+	},
+	/**
+	* 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, [
+			AST_NODE_TYPES.MemberExpression,
+			AST_NODE_TYPES.TSNonNullExpression,
+			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 === 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 AST_NODE_TYPES.TSTypeReference:
+				if (typeNode.typeName.type === AST_NODE_TYPES.Identifier) out.add(typeNode.typeName.name);
+				break;
+			case AST_NODE_TYPES.TSUnionType:
+			case AST_NODE_TYPES.TSIntersectionType:
+				typeNode.types.forEach((t) => ExhaustiveDepsUtils.collectTypeIdentifiers(t, out));
+				break;
+			case AST_NODE_TYPES.TSArrayType:
+				ExhaustiveDepsUtils.collectTypeIdentifiers(typeNode.elementType, out);
+				break;
+			case 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 !== AST_NODE_TYPES.ConditionalExpression) return [queryFn.value];
+		if (queryFn.value.consequent.type === AST_NODE_TYPES.Identifier && queryFn.value.consequent.name === "skipToken") return [queryFn.value.alternate];
+		if (queryFn.value.alternate.type === AST_NODE_TYPES.Identifier && queryFn.value.alternate.name === "skipToken") return [queryFn.value.consequent];
+		return [queryFn.value.consequent, queryFn.value.alternate];
+	}
+};
+var QUERY_KEY = "queryKey";
+var QUERY_FN = "queryFn";
+var name = "exhaustive-deps";
+var rule = ESLintUtils.RuleCreator(getDocsUrl)({
+	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, [
+				AST_NODE_TYPES.ArrowFunctionExpression,
+				AST_NODE_TYPES.FunctionExpression,
+				AST_NODE_TYPES.ConditionalExpression
+			])) return;
+			const queryKeyNode = dereferenceVariablesAndTypeAssertions(queryKey.value, context);
+			const queryFnNodes = ExhaustiveDepsUtils.getQueryFnNodes(queryFn);
+			const relevantRefs = queryFnNodes.flatMap((fnNode) => ASTUtils.getExternalRefs({
+				scopeManager,
+				sourceCode: context.sourceCode,
+				node: fnNode
+			})).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 !== 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 !== AST_NODE_TYPES.ArrayExpression) return [];
+	const closingBracket = sourceCode.getLastToken(queryKeyNode);
+	if (!closingBracket) return [];
+	const resultText = `[${[...queryKeyNode.elements.filter((el) => el !== null).map((el) => sourceCode.getText(el)), ...missingPaths].join(", ")}]`;
+	if (queryKeyNode.elements.length === 0) return [{
+		messageId: "fixTo",
+		data: { result: resultText },
+		fix: (fixer) => fixer.replaceText(queryKeyNode, resultText)
+	}];
+	const separator = sourceCode.getTokenBefore(closingBracket)?.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 < 256; ++i) {
+		if (visitedNodes.has(queryKeyNode)) return queryKeyNode;
+		visitedNodes.add(queryKeyNode);
+		switch (queryKeyNode.type) {
+			case AST_NODE_TYPES.TSAsExpression:
+				queryKeyNode = queryKeyNode.expression;
+				break;
+			case AST_NODE_TYPES.Identifier: {
+				const expression = ASTUtils.getReferencedExpressionByIdentifier({
+					context,
+					node: queryKeyNode
+				});
+				if (expression == null) return queryKeyNode;
+				queryKeyNode = expression;
+				break;
+			}
+			default: return queryKeyNode;
+		}
+	}
+	return queryKeyNode;
+}
+var name2 = "stable-query-client";
+var rule2 = ESLintUtils.RuleCreator(getDocsUrl)({
+	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 !== AST_NODE_TYPES.Identifier || node.callee.name !== "QueryClient" || node.parent.type !== 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 !== AST_NODE_TYPES.Identifier) return;
+					const nodeText = (context.sourceCode ?? context.getSourceCode()).getText(node);
+					const variableName = parent.id.name;
+					return (fixer) => {
+						return fixer.replaceTextRange([parent.range[0], parent.range[1]], `[${variableName}] = React.useState(() => ${nodeText})`);
+					};
+				})()
+			});
+		} };
+	})
+});
+var NoRestDestructuringUtils = { isObjectRestDestructuring(node) {
+	if (node.type !== AST_NODE_TYPES.ObjectPattern) return false;
+	return node.properties.some((p) => p.type === AST_NODE_TYPES.RestElement);
+} };
+var name3 = "no-rest-destructuring";
+var queryHooks = [
+	"useQuery",
+	"useQueries",
+	"useInfiniteQuery",
+	"useSuspenseQuery",
+	"useSuspenseQueries",
+	"useSuspenseInfiniteQuery"
+];
+var rule3 = ESLintUtils.RuleCreator(getDocsUrl)({
+	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 !== 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 === AST_NODE_TYPES.Identifier) queryResultVariables.add(returnValue.name);
+					return;
+				}
+				if (returnValue.type !== AST_NODE_TYPES.ArrayPattern) {
+					if (returnValue.type === 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 === AST_NODE_TYPES.Identifier && queryResultVariables.has(node.init.name) && NoRestDestructuringUtils.isObjectRestDestructuring(node.id)) context.report({
+					node,
+					messageId: "objectRestDestructure"
+				});
+			},
+			SpreadElement: (node) => {
+				if (node.argument.type === AST_NODE_TYPES.Identifier && queryResultVariables.has(node.argument.name)) context.report({
+					node,
+					messageId: "objectRestDestructure"
+				});
+			}
+		};
+	})
+});
+var name4 = "no-unstable-deps";
+var reactHookNames = [
+	"useEffect",
+	"useCallback",
+	"useMemo"
+];
+var allHookNames = ["useMutation", ...[
+	"useQuery",
+	"useSuspenseQuery",
+	"useQueries",
+	"useSuspenseQueries",
+	"useInfiniteQuery",
+	"useSuspenseInfiniteQuery"
+]];
+var rule4 = ESLintUtils.RuleCreator(getDocsUrl)({
+	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;
+		}
+		function collectVariableNames(pattern, queryHook) {
+			if (pattern.type === 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 !== AST_NODE_TYPES.ObjectExpression) return false;
+			return firstArg.properties.some((prop) => prop.type === AST_NODE_TYPES.Property && prop.key.type === 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 === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === 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 === AST_NODE_TYPES.CallExpression && node.init.callee.type === 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 === AST_NODE_TYPES.ArrayExpression) node.arguments[1].elements.forEach((dep) => {
+					if (dep !== null && dep.type === AST_NODE_TYPES.Identifier && trackedVariables[dep.name] !== void 0) {
+						const queryHook = trackedVariables[dep.name];
+						context.report({
+							node: dep,
+							messageId: "noUnstableDeps",
+							data: {
+								queryHook,
+								reactHook
+							}
+						});
+					}
+				});
+			}
+		};
+	})
+});
+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 inOrderIterator = 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;
+	}).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;
+}
+var createRule5 = 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 !== 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 sortedProperties = sortDataByOrder(allProperties.flatMap((p, index) => {
+					if (p.type === AST_NODE_TYPES.Property && p.key.type === AST_NODE_TYPES.Identifier) return {
+						name: p.key.name,
+						property: p
+					};
+					else return {
+						name: `_property_${index}`,
+						property: p
+					};
+				}), 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);
+					}
+				});
+			} };
+		})
+	});
+}
+var infiniteQueryFunctions = [
+	"infiniteQueryOptions",
+	"useInfiniteQuery",
+	"useSuspenseInfiniteQuery"
+];
+var sortRules = [[["queryFn"], ["getPreviousPageParam", "getNextPageParam"]]];
+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);
+var name6 = "no-void-query-fn";
+var rule6 = ESLintUtils.RuleCreator(getDocsUrl)({
+	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));
+	const typeString = checker.typeToString(awaited);
+	return typeString === "void" || typeString === "undefined";
+}
+var mutationFunctions = ["useMutation"];
+var sortRules2 = [[["onMutate"], ["onError", "onSettled"]]];
+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);
+var name8 = "prefer-query-options";
+var queryHooks2 = [
+	"useQuery",
+	"useInfiniteQuery",
+	"useSuspenseQuery",
+	"useSuspenseInfiniteQuery",
+	"usePrefetchQuery",
+	"usePrefetchInfiniteQuery"
+];
+var queriesHooks = ["useQueries", "useSuspenseQueries"];
+var filterHooks = ["useIsFetching"];
+var queryClientOptionMethods = [
+	"fetchQuery",
+	"prefetchQuery",
+	"fetchInfiniteQuery",
+	"prefetchInfiniteQuery",
+	"ensureQueryData",
+	"ensureInfiniteQueryData"
+];
+var queryClientQueryKeyMethods = [
+	"getQueryData",
+	"setQueryData",
+	"getQueryState",
+	"setQueryDefaults",
+	"getQueryDefaults"
+];
+var queryClientFilterMethods = [
+	"invalidateQueries",
+	"cancelQueries",
+	"refetchQueries",
+	"removeQueries",
+	"resetQueries",
+	"isFetching",
+	"getQueriesData",
+	"setQueriesData"
+];
+var queryOptionsBuilders = ["queryOptions", "infiniteQueryOptions"];
+var rule8 = ESLintUtils.RuleCreator(getDocsUrl)({
+	name: name8,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Prefer using queryOptions() to co-locate queryKey and queryFn",
+			recommended: "strict"
+		},
+		messages: {
+			preferQueryOptions: "Prefer using queryOptions() or infiniteQueryOptions() to co-locate queryKey and queryFn.",
+			preferQueryOptionsQueryKey: "Prefer referencing a queryKey from a queryOptions() result instead of typing it manually."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create: detectTanstackQueryImports((context, _, helpers) => {
+		function reportInlineQueryOptions(node) {
+			if (ASTUtils.isObjectExpression(node) && hasInlineQueryOptions(node)) context.report({
+				node,
+				messageId: "preferQueryOptions"
+			});
+		}
+		function reportInlineFilterQueryKey(node) {
+			if (ASTUtils.isObjectExpression(node) && hasInlineFilterQueryKey(node)) context.report({
+				node,
+				messageId: "preferQueryOptionsQueryKey"
+			});
+		}
+		return { CallExpression: (node) => {
+			if (ASTUtils.isIdentifier(node.callee)) {
+				const importedName = getTanstackImportName(context, helpers, node.callee);
+				if (importedName === null) return;
+				if (queryOptionsBuilders.includes(importedName)) return;
+				const options2 = node.arguments[0];
+				if (options2 === void 0) return;
+				if (queryHooks2.includes(importedName)) {
+					reportInlineQueryOptions(options2);
+					return;
+				}
+				if (queriesHooks.includes(importedName) && ASTUtils.isObjectExpression(options2)) {
+					const queries = ASTUtils.findPropertyWithIdentifierKey(options2.properties, "queries")?.value;
+					if (queries !== void 0) getQueryObjects(queries).forEach((query) => {
+						reportInlineQueryOptions(query);
+					});
+					return;
+				}
+				if (filterHooks.includes(importedName)) reportInlineFilterQueryKey(options2);
+				return;
+			}
+			if (node.callee.type !== AST_NODE_TYPES.MemberExpression || !ASTUtils.isIdentifier(node.callee.property) || !isTanstackQueryClient(node.callee.object, context, helpers)) return;
+			const method = node.callee.property.name;
+			const options = node.arguments[0];
+			if (options === void 0) return;
+			if (queryClientOptionMethods.includes(method)) {
+				reportInlineQueryOptions(options);
+				return;
+			}
+			if (queryClientQueryKeyMethods.includes(method) && isInlineArrayExpression(options)) {
+				context.report({
+					node: options,
+					messageId: "preferQueryOptionsQueryKey"
+				});
+				return;
+			}
+			if (queryClientFilterMethods.includes(method)) reportInlineFilterQueryKey(options);
+		} };
+	})
+});
+function hasInlineQueryOptions(node) {
+	return ASTUtils.findPropertyWithIdentifierKey(node.properties, "queryKey") !== void 0 || ASTUtils.findPropertyWithIdentifierKey(node.properties, "queryFn") !== void 0;
+}
+function hasInlineFilterQueryKey(node) {
+	const queryKey = ASTUtils.findPropertyWithIdentifierKey(node.properties, "queryKey")?.value;
+	return queryKey !== void 0 && isInlineArrayExpression(queryKey);
+}
+function isInlineArrayExpression(node) {
+	return unwrapTypeAssertions(node).type === AST_NODE_TYPES.ArrayExpression;
+}
+function getReturnedObjectExpressions(node) {
+	if (ASTUtils.isObjectExpression(node)) return [node];
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression) return getReturnedObjectExpressions(node.body);
+	if (node.type === AST_NODE_TYPES.BlockStatement) return node.body.flatMap((statement) => {
+		if (statement.type === AST_NODE_TYPES.ReturnStatement && statement.argument !== null) return getReturnedObjectExpressions(statement.argument);
+		return [];
+	});
+	if (node.type === AST_NODE_TYPES.ConditionalExpression) return [...getReturnedObjectExpressions(node.consequent), ...getReturnedObjectExpressions(node.alternate)];
+	if (node.type === AST_NODE_TYPES.LogicalExpression) return [...getReturnedObjectExpressions(node.left), ...getReturnedObjectExpressions(node.right)];
+	if (node.type === AST_NODE_TYPES.SequenceExpression) return node.expressions.flatMap((expression) => getReturnedObjectExpressions(expression));
+	return [];
+}
+function getQueryObjects(node) {
+	if (node.type === AST_NODE_TYPES.ArrayExpression) return node.elements.flatMap((element) => {
+		if (element !== null && ASTUtils.isObjectExpression(element)) return [element];
+		return [];
+	});
+	if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && ASTUtils.isIdentifierWithName(node.callee.property, "map")) {
+		const mapper = node.arguments[0];
+		if (mapper?.type === AST_NODE_TYPES.ArrowFunctionExpression || mapper?.type === AST_NODE_TYPES.FunctionExpression) return getReturnedObjectExpressions(mapper);
+	}
+	return [];
+}
+function isTanstackQueryClient(node, context, helpers) {
+	const source = resolveQueryClientSource(node, context);
+	if (source.type === AST_NODE_TYPES.CallExpression && ASTUtils.isIdentifier(source.callee)) return getTanstackImportName(context, helpers, source.callee) === "useQueryClient";
+	if (source.type === AST_NODE_TYPES.NewExpression && ASTUtils.isIdentifier(source.callee)) return getTanstackImportName(context, helpers, source.callee) === "QueryClient";
+	return false;
+}
+function getTanstackImportName(context, helpers, node) {
+	if (!helpers.isTanstackQueryImport(node)) return null;
+	const definition = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === node)?.resolved?.defs[0]?.node;
+	if (definition?.type !== AST_NODE_TYPES.ImportSpecifier || definition.imported.type !== AST_NODE_TYPES.Identifier) return null;
+	return definition.imported.name;
+}
+function resolveQueryClientSource(node, context) {
+	const visitedNodes = /* @__PURE__ */ new Set();
+	while (!visitedNodes.has(node)) {
+		visitedNodes.add(node);
+		if (node.type === AST_NODE_TYPES.ChainExpression) {
+			node = node.expression;
+			continue;
+		}
+		node = unwrapTypeAssertions(node);
+		if (node.type !== AST_NODE_TYPES.Identifier) return node;
+		const expression = ASTUtils.getReferencedExpressionByIdentifier({
+			context,
+			node
+		});
+		if (expression === null) return node;
+		node = expression;
+	}
+	return node;
+}
+function unwrapTypeAssertions(node) {
+	while (node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSSatisfiesExpression || node.type === AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
+	return node;
+}
+var rules = {
+	[name]: rule,
+	[name2]: rule2,
+	[name3]: rule3,
+	[name4]: rule4,
+	[name5]: rule5,
+	[name6]: rule6,
+	[name7]: rule7,
+	[name8]: rule8
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+eslint-plugin-query@5.100.10_eslint@10.3.0_jiti@2.7.0__typescript@6.0.3/node_modules/@tanstack/eslint-plugin-query/build/modern/index.js
+var recommendedRules = {
+	"@tanstack/query/exhaustive-deps": "error",
+	"@tanstack/query/no-rest-destructuring": "warn",
+	"@tanstack/query/stable-query-client": "error",
+	"@tanstack/query/no-unstable-deps": "error",
+	"@tanstack/query/infinite-query-property-order": "error",
+	"@tanstack/query/no-void-query-fn": "error",
+	"@tanstack/query/mutation-property-order": "error"
+};
+var recommendedStrictRules = {
+	...recommendedRules,
+	"@tanstack/query/prefer-query-options": "error"
+};
+var plugin = {
+	meta: { name: "@tanstack/eslint-plugin-query" },
+	configs: {
+		recommended: {
+			plugins: ["@tanstack/query"],
+			rules: recommendedRules
+		},
+		recommendedStrict: {
+			plugins: ["@tanstack/query"],
+			rules: recommendedStrictRules
+		},
+		"flat/recommended": [{
+			name: "tanstack/query/flat/recommended",
+			plugins: { "@tanstack/query": {} },
+			rules: recommendedRules
+		}],
+		"flat/recommended-strict": [{
+			name: "tanstack/query/flat/recommended-strict",
+			plugins: { "@tanstack/query": {} },
+			rules: recommendedStrictRules
+		}]
+	},
+	rules
+};
+plugin.configs["flat/recommended"][0].plugins["@tanstack/query"] = plugin;
+plugin.configs["flat/recommended-strict"][0].plugins["@tanstack/query"] = plugin;
+var index_default = plugin;
+//#endregion
+export { index_default as default, plugin };