eslint-plugin-zod-mini 0.1.0

package/dist/rules/consistent-import.mjs

@@ -0,0 +1,152 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { isZodImportSource } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-import.ts
+const IMPORT_SYNTAXES = ["namespace", "named"];
+/**
+* Determines whether the first import in a group is valid for a given import
+* syntax (`named` or `namespace`), taking into account whether the group
+* contains only type imports.
+*
+* Rules enforced:
+* - For `named` syntax:
+*   - The first import must have exactly one specifier
+*   - That specifier must be a named import of identifier `z`
+* - For `namespace` syntax:
+*   - The first import must have exactly one namespace specifier
+* - If the group contains only type imports, the first import must explicitly
+*   be declared as `import type`
+*
+* @param group - Metadata describing the import group
+* @param syntax - Expected import syntax for the group
+* @returns `true` if the first import matches the expected syntax and type rules
+*/
+function isGroupFirstImportKindValidForSyntax(group, syntax) {
+	const { hasOnlyTypeImports, nodes } = group;
+	const [firstImportNode] = nodes;
+	const { specifiers, importKind } = firstImportNode;
+	if (specifiers.length !== 1) return false;
+	const [specifier] = specifiers;
+	if (!(syntax === "named" ? specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "z" : specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)) return false;
+	if (hasOnlyTypeImports) return importKind === "type";
+	return true;
+}
+function shouldIdentifierBeRenamed(node) {
+	if (node.parent.type === AST_NODE_TYPES.ImportSpecifier) return false;
+	if (node.parent.type === AST_NODE_TYPES.MemberExpression && node.parent.object.type === AST_NODE_TYPES.Identifier && node.parent.object.name !== node.name) return false;
+	return true;
+}
+/**
+* From a given specifiers retrieve the most significant to use when creating an alias import
+*/
+function getNamespaceAliasNameFrom(node) {
+	if (node.type === AST_NODE_TYPES.ImportDefaultSpecifier || node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) return node.local.name;
+	if (node.imported.type === AST_NODE_TYPES.Identifier && node.imported.name === "z") return node.local.name;
+	return null;
+}
+const consistentImport = createZodMiniPluginRule({
+	name: "consistent-import",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource: "zod-mini",
+			description: "Enforce a consistent import style for Zod Mini"
+		},
+		fixable: "code",
+		messages: {
+			changeImportSyntax: "Use a {{syntax}} import for Zod Mini.",
+			removeDuplicate: "Remove duplicate Zod Mini import; Zod Mini is already imported.",
+			convertUsage: "Update Zod Mini usage to match the {{syntax}} import syntax."
+		},
+		schema: [{
+			type: "object",
+			properties: { syntax: {
+				description: "Specifies the import syntax to use for Zod Mini.",
+				type: "string",
+				enum: IMPORT_SYNTAXES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ syntax: "namespace" }],
+	create(context, [options]) {
+		const { syntax } = options;
+		const { sourceCode } = context;
+		const importGroups = {};
+		return {
+			ImportDeclaration(node) {
+				const { source, importKind } = node;
+				if (!isZodImportSource(source.value, "zod-mini")) return;
+				if (!importGroups[source.value]) importGroups[source.value] = {
+					hasOnlyTypeImports: true,
+					nodes: []
+				};
+				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
+				importGroups[source.value].nodes.push(node);
+			},
+			"Program:exit": function() {
+				let namespaceAliasNameIndex = 0;
+				for (const importGroup of Object.values(importGroups)) {
+					const { hasOnlyTypeImports, nodes } = importGroup;
+					const [firstImportNode, ...othersImportNodes] = nodes;
+					/**
+					* Variable to track all specifiers that later are used by {@link getDeclaredVariables}
+					* to add the namespace prefix
+					*/
+					const nodesWithVariablesToUpdate = [];
+					let namespaceAliasName = null;
+					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+						if (!namespaceAliasName) {
+							namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+							if (namespaceAliasName) continue;
+						}
+						nodesWithVariablesToUpdate.push(specifier);
+					}
+					if (!namespaceAliasName) {
+						namespaceAliasName = "z";
+						if (namespaceAliasNameIndex > 0) {
+							namespaceAliasName = `z${namespaceAliasNameIndex}`;
+							namespaceAliasNameIndex += 1;
+						}
+					}
+					if (!isGroupFirstImportKindValidForSyntax(importGroup, syntax)) context.report({
+						node: firstImportNode,
+						messageId: "changeImportSyntax",
+						data: { syntax },
+						fix(fixer) {
+							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
+							let importSpecifier;
+							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
+							else importSpecifier = `{ z as ${namespaceAliasName} }`;
+							else importSpecifier = `* as ${namespaceAliasName}`;
+							const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
+							return fixer.replaceText(firstImportNode, newImportText);
+						}
+					});
+					const allReferences = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it)).flatMap((it) => it.references);
+					for (const ref of allReferences) {
+						const { identifier } = ref;
+						if (shouldIdentifierBeRenamed(identifier)) context.report({
+							node: identifier,
+							messageId: "convertUsage",
+							data: { syntax },
+							fix(fixer) {
+								const newId = `${namespaceAliasName}.${identifier.name}`;
+								return fixer.replaceText(identifier, newId);
+							}
+						});
+					}
+					for (const extraImport of othersImportNodes) context.report({
+						node: extraImport,
+						messageId: "removeDuplicate",
+						fix(fixer) {
+							return fixer.removeRange(extraImport.range);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { consistentImport };

package/dist/rules/consistent-object-schema-type.cjs

@@ -0,0 +1,82 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/consistent-object-schema-type.ts
+const ZOD_OBJECT_METHODS = [
+	"object",
+	"looseObject",
+	"strictObject"
+];
+const defaultOptions = { allow: ["object"] };
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const consistentObjectSchemaType = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "consistent-object-schema-type",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent usage of Zod Mini schema methods"
+		},
+		messages: {
+			consistentMethod: "Inconsistent Zod Mini object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+			useMethod: "Replace with '{{expected}}'."
+		},
+		schema: [{
+			type: "object",
+			properties: { allow: {
+				type: "array",
+				description: "Decides which object methods are allowed",
+				items: {
+					type: "string",
+					enum: [...ZOD_OBJECT_METHODS]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ allow: allowedList }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const schemaType = detectZodSchemaRootNode(node)?.schemaType;
+				if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) return;
+				if (allowedList.includes(schemaType)) return;
+				const { callee } = node;
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "consistentMethod",
+						data: {
+							actual: schemaType,
+							allowedList: allowedList.join(",")
+						}
+					});
+					return;
+				}
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) context.report({
+					node,
+					messageId: "consistentMethod",
+					data: {
+						actual: schemaType,
+						allowedList: allowedList.join(",")
+					},
+					suggest: allowedList.map((it) => ({
+						messageId: "useMethod",
+						data: { expected: it },
+						fix(fixer) {
+							return fixer.replaceText(callee.property, it);
+						}
+					}))
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentObjectSchemaType = consistentObjectSchemaType;

package/dist/rules/consistent-object-schema-type.mjs

@@ -0,0 +1,81 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-object-schema-type.ts
+const ZOD_OBJECT_METHODS = [
+	"object",
+	"looseObject",
+	"strictObject"
+];
+const defaultOptions = { allow: ["object"] };
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const consistentObjectSchemaType = createZodMiniPluginRule({
+	name: "consistent-object-schema-type",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent usage of Zod Mini schema methods"
+		},
+		messages: {
+			consistentMethod: "Inconsistent Zod Mini object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+			useMethod: "Replace with '{{expected}}'."
+		},
+		schema: [{
+			type: "object",
+			properties: { allow: {
+				type: "array",
+				description: "Decides which object methods are allowed",
+				items: {
+					type: "string",
+					enum: [...ZOD_OBJECT_METHODS]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ allow: allowedList }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const schemaType = detectZodSchemaRootNode(node)?.schemaType;
+				if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) return;
+				if (allowedList.includes(schemaType)) return;
+				const { callee } = node;
+				if (callee.type === AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "consistentMethod",
+						data: {
+							actual: schemaType,
+							allowedList: allowedList.join(",")
+						}
+					});
+					return;
+				}
+				if (callee.type === AST_NODE_TYPES.MemberExpression) context.report({
+					node,
+					messageId: "consistentMethod",
+					data: {
+						actual: schemaType,
+						allowedList: allowedList.join(",")
+					},
+					suggest: allowedList.map((it) => ({
+						messageId: "useMethod",
+						data: { expected: it },
+						fix(fixer) {
+							return fixer.replaceText(callee.property, it);
+						}
+					}))
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { consistentObjectSchemaType };

package/dist/rules/consistent-schema-output-type-style.cjs

@@ -0,0 +1,70 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/consistent-schema-output-type-style.ts
+const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "consistent-schema-output-type-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent use of z.infer or z.output for schema type inference"
+		},
+		messages: {
+			useInfer: "Use infer instead of output.",
+			useOutput: "Use output instead of infer."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style to use for schema type inference",
+				type: "string",
+				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ style: "output" }],
+	create(context, [{ style }]) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			TSTypeReference(node) {
+				const { typeName } = node;
+				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.TSQualifiedName) {
+					const { left, right } = typeName;
+					if (left.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
+					const usedStyle = right.name;
+					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
+					context.report({
+						node: right,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							return fixer.replaceText(right, style);
+						}
+					});
+					return;
+				}
+				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					const originalName = getNamedImportOriginal(typeName.name);
+					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
+					const targetLocalName = getNamedImportLocal(style);
+					context.report({
+						node: typeName,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							if (!targetLocalName || targetLocalName === "infer") return null;
+							return fixer.replaceText(typeName, targetLocalName);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentSchemaOutputTypeStyle = consistentSchemaOutputTypeStyle;

package/dist/rules/consistent-schema-output-type-style.mjs

@@ -0,0 +1,69 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-schema-output-type-style.ts
+const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const consistentSchemaOutputTypeStyle = createZodMiniPluginRule({
+	name: "consistent-schema-output-type-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent use of z.infer or z.output for schema type inference"
+		},
+		messages: {
+			useInfer: "Use infer instead of output.",
+			useOutput: "Use output instead of infer."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style to use for schema type inference",
+				type: "string",
+				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ style: "output" }],
+	create(context, [{ style }]) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			TSTypeReference(node) {
+				const { typeName } = node;
+				if (typeName.type === AST_NODE_TYPES.TSQualifiedName) {
+					const { left, right } = typeName;
+					if (left.type !== AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
+					const usedStyle = right.name;
+					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
+					context.report({
+						node: right,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							return fixer.replaceText(right, style);
+						}
+					});
+					return;
+				}
+				if (typeName.type === AST_NODE_TYPES.Identifier) {
+					const originalName = getNamedImportOriginal(typeName.name);
+					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
+					const targetLocalName = getNamedImportLocal(style);
+					context.report({
+						node: typeName,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							if (!targetLocalName || targetLocalName === "infer") return null;
+							return fixer.replaceText(typeName, targetLocalName);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { consistentSchemaOutputTypeStyle };

package/dist/rules/consistent-schema-var-name.cjs

@@ -0,0 +1,76 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/consistent-schema-var-name.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const consistentSchemaVarName = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "consistent-schema-var-name",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce a consistent naming convention for Zod Mini schema variables"
+		},
+		messages: { invalidName: "Rename this Zod Mini schema to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: {
+				before: {
+					type: "string",
+					description: "The required prefix for Zod Mini schema variables"
+				},
+				after: {
+					type: "string",
+					description: "The required suffix for Zod Mini schema variables"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ after: "Schema" }],
+	create(context, [{ before = "", after = "" }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			VariableDeclarator(node) {
+				const initNode = node.init;
+				if (initNode?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
+				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+				if ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+				const { name } = node.id;
+				const validPrefix = !before || name.startsWith(before);
+				const validSuffix = !after || name.endsWith(after);
+				if (validPrefix && validSuffix) return;
+				const expected = (validPrefix ? "" : before) + name + (validSuffix ? "" : after);
+				context.report({
+					node,
+					messageId: "invalidName",
+					data: { expected }
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentSchemaVarName = consistentSchemaVarName;

package/dist/rules/consistent-schema-var-name.mjs

@@ -0,0 +1,75 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-schema-var-name.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const consistentSchemaVarName = createZodMiniPluginRule({
+	name: "consistent-schema-var-name",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce a consistent naming convention for Zod Mini schema variables"
+		},
+		messages: { invalidName: "Rename this Zod Mini schema to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: {
+				before: {
+					type: "string",
+					description: "The required prefix for Zod Mini schema variables"
+				},
+				after: {
+					type: "string",
+					description: "The required suffix for Zod Mini schema variables"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ after: "Schema" }],
+	create(context, [{ before = "", after = "" }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			VariableDeclarator(node) {
+				const initNode = node.init;
+				if (initNode?.type !== AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
+				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+				if ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== AST_NODE_TYPES.Identifier) return;
+				const { name } = node.id;
+				const validPrefix = !before || name.startsWith(before);
+				const validSuffix = !after || name.endsWith(after);
+				if (validPrefix && validSuffix) return;
+				const expected = (validPrefix ? "" : before) + name + (validSuffix ? "" : after);
+				context.report({
+					node,
+					messageId: "invalidName",
+					data: { expected }
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { consistentSchemaVarName };

package/dist/rules/no-any-schema.cjs

@@ -0,0 +1,63 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/no-any-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const noAnySchema = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "no-any-schema",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.any()` in Zod Mini schemas"
+		},
+		messages: {
+			noZAny: "Using `z.any()` is not allowed. Please use a more specific schema.",
+			useUnknown: "Replace `z.any()` with `z.unknown()`"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "any") return;
+				const { callee } = node;
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+					return;
+				}
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) {
+					const [{ node: schemaMethod }] = collectZodChainMethods(node);
+					const schemaMethodCallee = schemaMethod.callee;
+					if (schemaMethodCallee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && schemaMethodCallee.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+						context.report({
+							node,
+							messageId: "noZAny",
+							suggest: [{
+								messageId: "useUnknown",
+								fix(fixer) {
+									return fixer.replaceText(schemaMethodCallee.property, "unknown");
+								}
+							}]
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.noAnySchema = noAnySchema;