eslint-plugin-zod-mini 0.1.0

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

@@ -0,0 +1,62 @@
+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/no-any-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const noAnySchema = 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 === AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+					return;
+				}
+				if (callee.type === AST_NODE_TYPES.MemberExpression) {
+					const [{ node: schemaMethod }] = collectZodChainMethods(node);
+					const schemaMethodCallee = schemaMethod.callee;
+					if (schemaMethodCallee.type === AST_NODE_TYPES.MemberExpression && schemaMethodCallee.property.type === 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
+export { noAnySchema };

package/dist/rules/no-empty-custom-schema.cjs

@@ -0,0 +1,36 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/no-empty-custom-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, require("@eslint-zod/utils").createZodSchemaImportTrack)("zod-mini");
+const noEmptyCustomSchema = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "no-empty-custom-schema",
+	meta: {
+		hasSuggestions: false,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.custom()` without arguments"
+		},
+		messages: { noEmptyCustomSchema: "You should provide a validate function within `z.custom()`" },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType !== "custom") return;
+				const customCallNode = collectZodChainMethods(node).find((method) => method.name === "custom")?.node;
+				if (customCallNode?.arguments.length === 0) context.report({
+					node: customCallNode,
+					messageId: "noEmptyCustomSchema"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noEmptyCustomSchema = noEmptyCustomSchema;

package/dist/rules/no-empty-custom-schema.mjs

@@ -0,0 +1,36 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+//#region src/rules/no-empty-custom-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const noEmptyCustomSchema = createZodMiniPluginRule({
+	name: "no-empty-custom-schema",
+	meta: {
+		hasSuggestions: false,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.custom()` without arguments"
+		},
+		messages: { noEmptyCustomSchema: "You should provide a validate function within `z.custom()`" },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType !== "custom") return;
+				const customCallNode = collectZodChainMethods(node).find((method) => method.name === "custom")?.node;
+				if (customCallNode?.arguments.length === 0) context.report({
+					node: customCallNode,
+					messageId: "noEmptyCustomSchema"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noEmptyCustomSchema };

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

@@ -0,0 +1,31 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/no-unknown-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, require("@eslint-zod/utils").createZodSchemaImportTrack)("zod-mini");
+const noUnknownSchema = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "no-unknown-schema",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.unknown()` in Zod Mini schemas"
+		},
+		messages: { noZUnknown: "Using `z.unknown()` is not allowed. Please use a more specific schema." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType === "unknown") context.report({
+					node,
+					messageId: "noZUnknown"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noUnknownSchema = noUnknownSchema;

package/dist/rules/no-unknown-schema.mjs

@@ -0,0 +1,31 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+//#region src/rules/no-unknown-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const noUnknownSchema = createZodMiniPluginRule({
+	name: "no-unknown-schema",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.unknown()` in Zod Mini schemas"
+		},
+		messages: { noZUnknown: "Using `z.unknown()` is not allowed. Please use a more specific schema." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType === "unknown") context.report({
+					node,
+					messageId: "noZUnknown"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noUnknownSchema };

package/dist/rules/prefer-meta.cjs

@@ -0,0 +1,46 @@
+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/prefer-meta.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const preferMeta = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "prefer-meta",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce usage of `z.meta()` over `z.describe()`"
+		},
+		messages: { preferMeta: "The `z.describe()` function still exists for compatibility with Zod 3, but `z.meta()` is now the recommended approach." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const { callee } = node;
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && callee.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && callee.property.name === "describe" && callee.object.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && isZodNamespace(callee.object.name)) {
+					const [describeArg] = node.arguments;
+					context.report({
+						node,
+						messageId: "preferMeta",
+						fix(fixer) {
+							return [fixer.replaceText(callee.property, "meta"), fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`)];
+						}
+					});
+					return;
+				}
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && getNamedImportOriginal(callee.name) === "describe") context.report({
+					node,
+					messageId: "preferMeta"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.preferMeta = preferMeta;

package/dist/rules/prefer-meta.mjs

@@ -0,0 +1,45 @@
+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/prefer-meta.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const preferMeta = createZodMiniPluginRule({
+	name: "prefer-meta",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce usage of `z.meta()` over `z.describe()`"
+		},
+		messages: { preferMeta: "The `z.describe()` function still exists for compatibility with Zod 3, but `z.meta()` is now the recommended approach." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const { callee } = node;
+				if (callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "describe" && callee.object.type === AST_NODE_TYPES.Identifier && isZodNamespace(callee.object.name)) {
+					const [describeArg] = node.arguments;
+					context.report({
+						node,
+						messageId: "preferMeta",
+						fix(fixer) {
+							return [fixer.replaceText(callee.property, "meta"), fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`)];
+						}
+					});
+					return;
+				}
+				if (callee.type === AST_NODE_TYPES.Identifier && getNamedImportOriginal(callee.name) === "describe") context.report({
+					node,
+					messageId: "preferMeta"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferMeta };

package/dist/rules/prefer-namespace-import.cjs

@@ -0,0 +1,117 @@
+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/prefer-namespace-import.ts
+function isGroupFirstImportTypeNamespace(group) {
+	const { hasOnlyTypeImports, nodes: [firstImportNode] } = group;
+	const { specifiers } = firstImportNode;
+	if (specifiers.length === 1 && specifiers[0].type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier) if (hasOnlyTypeImports) {
+		if (firstImportNode.importKind === "type") return true;
+	} else return true;
+	return false;
+}
+function shouldIdentifierBeRenamed(node) {
+	if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) return false;
+	if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && node.parent.object.type === _typescript_eslint_utils.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 === _typescript_eslint_utils.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier) return node.local.name;
+	if (node.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.imported.name === "z") return node.local.name;
+	return null;
+}
+const preferNamespaceImport = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "prefer-namespace-import",
+	meta: {
+		type: "suggestion",
+		deprecated: { message: "Use `zod-mini/consistent-import` with `{ syntax: 'namespace' }`" },
+		docs: {
+			zodImportAllowedSource: "zod-mini",
+			description: "Enforce importing zod/mini as a namespace import (`import * as z from 'zod/mini'`)"
+		},
+		fixable: "code",
+		messages: {
+			useNamespace: "Import Zod Mini with a namespace import",
+			removeDuplicate: "Zod Mini is already imported via namespace import",
+			convertUsage: "Convert to namespace usage"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { sourceCode } = context;
+		const importGroups = {};
+		return {
+			ImportDeclaration(node) {
+				const { source, importKind } = node;
+				if (!(0, _eslint_zod_utils.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 (!isGroupFirstImportTypeNamespace(importGroup)) context.report({
+						node: firstImportNode,
+						messageId: "useNamespace",
+						fix(fixer) {
+							const newImportText = `import ${hasOnlyTypeImports ? "type " : ""}* as ${namespaceAliasName} 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",
+							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
+exports.preferNamespaceImport = preferNamespaceImport;

package/dist/rules/prefer-namespace-import.mjs

@@ -0,0 +1,116 @@
+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/prefer-namespace-import.ts
+function isGroupFirstImportTypeNamespace(group) {
+	const { hasOnlyTypeImports, nodes: [firstImportNode] } = group;
+	const { specifiers } = firstImportNode;
+	if (specifiers.length === 1 && specifiers[0].type === AST_NODE_TYPES.ImportNamespaceSpecifier) if (hasOnlyTypeImports) {
+		if (firstImportNode.importKind === "type") return true;
+	} else return true;
+	return false;
+}
+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 preferNamespaceImport = createZodMiniPluginRule({
+	name: "prefer-namespace-import",
+	meta: {
+		type: "suggestion",
+		deprecated: { message: "Use `zod-mini/consistent-import` with `{ syntax: 'namespace' }`" },
+		docs: {
+			zodImportAllowedSource: "zod-mini",
+			description: "Enforce importing zod/mini as a namespace import (`import * as z from 'zod/mini'`)"
+		},
+		fixable: "code",
+		messages: {
+			useNamespace: "Import Zod Mini with a namespace import",
+			removeDuplicate: "Zod Mini is already imported via namespace import",
+			convertUsage: "Convert to namespace usage"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		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 (!isGroupFirstImportTypeNamespace(importGroup)) context.report({
+						node: firstImportNode,
+						messageId: "useNamespace",
+						fix(fixer) {
+							const newImportText = `import ${hasOnlyTypeImports ? "type " : ""}* as ${namespaceAliasName} 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",
+							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 { preferNamespaceImport };

package/dist/rules/require-brand-type-parameter.cjs

@@ -0,0 +1,49 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/require-brand-type-parameter.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, require("@eslint-zod/utils").createZodSchemaImportTrack)("zod-mini");
+const requireBrandTypeParameter = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "require-brand-type-parameter",
+	meta: {
+		hasSuggestions: true,
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Require type parameter on `.brand()` functions"
+		},
+		messages: {
+			missingTypeParameter: "Type parameter is required when using `.brand()`",
+			removeBrandFunction: "Brand is a static-only construct. If not parameter is required consider removal"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const brandMethod = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "brand");
+				if (!brandMethod) return;
+				const brandNode = brandMethod.node;
+				const { typeArguments } = brandNode;
+				if (typeArguments && typeArguments.params.length > 0) return;
+				const brandCalleeNode = brandNode.callee;
+				context.report({
+					messageId: "missingTypeParameter",
+					node: brandCalleeNode.property,
+					suggest: [{
+						messageId: "removeBrandFunction",
+						fix(fixer) {
+							return fixer.removeRange([brandCalleeNode.object.range[1], brandNode.range[1]]);
+						}
+					}]
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.requireBrandTypeParameter = requireBrandTypeParameter;

package/dist/rules/require-brand-type-parameter.mjs

@@ -0,0 +1,49 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+//#region src/rules/require-brand-type-parameter.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const requireBrandTypeParameter = createZodMiniPluginRule({
+	name: "require-brand-type-parameter",
+	meta: {
+		hasSuggestions: true,
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Require type parameter on `.brand()` functions"
+		},
+		messages: {
+			missingTypeParameter: "Type parameter is required when using `.brand()`",
+			removeBrandFunction: "Brand is a static-only construct. If not parameter is required consider removal"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const brandMethod = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "brand");
+				if (!brandMethod) return;
+				const brandNode = brandMethod.node;
+				const { typeArguments } = brandNode;
+				if (typeArguments && typeArguments.params.length > 0) return;
+				const brandCalleeNode = brandNode.callee;
+				context.report({
+					messageId: "missingTypeParameter",
+					node: brandCalleeNode.property,
+					suggest: [{
+						messageId: "removeBrandFunction",
+						fix(fixer) {
+							return fixer.removeRange([brandCalleeNode.object.range[1], brandNode.range[1]]);
+						}
+					}]
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { requireBrandTypeParameter };