eslint-plugin-zod 3.8.0 → 3.10.0

package/README.md

@@ -43,6 +43,7 @@ This plugin is primarily built for `zod`, so some rules are exclusive to `zod` a
 | [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod                                                     | ✅    | 🔧  |     |     |
 | [consistent-import-source](docs/rules/consistent-import-source.md)                       | Enforce consistent source from Zod imports                                                    |       |     | 💡  |     |
 | [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)             | Enforce consistent usage of Zod schema methods                                                |       |     | 💡  |     |
+| [consistent-schema-name](docs/rules/consistent-schema-name.md)                           | Enforce a consistent naming convention for Zod schema variables                               | ✅ ✔️ |     |     |     |
 | [consistent-schema-output-type-style](docs/rules/consistent-schema-output-type-style.md) | Enforce consistent use of z.infer or z.output for schema type inference                       |       | 🔧  |     |     |
 | [no-any-schema](docs/rules/no-any-schema.md)                                             | Disallow usage of `z.any()` in Zod schemas                                                    | ✅ ✔️ |     | 💡  |     |
 | [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                           | Disallow usage of `z.custom()` without arguments                                              | ✅    |     |     |     |
@@ -51,22 +52,27 @@ This plugin is primarily built for `zod`, so some rules are exclusive to `zod` a
 | [prefer-namespace-import](docs/rules/prefer-namespace-import.md)                         | Enforce importing zod as a namespace import (`import * as z from 'zod'`)                      |       | 🔧  |     | ❌  |
 | [require-brand-type-parameter](docs/rules/require-brand-type-parameter.md)               | Require type parameter on `.brand()` functions                                                | ✅ ✔️ |     | 💡  |     |
 | [require-error-message](docs/rules/require-error-message.md)                             | Enforce that custom refinements include an error message                                      | ✅ ✔️ | 🔧  |     |     |
-| [require-schema-suffix](docs/rules/require-schema-suffix.md)                             | Require schema suffix when declaring a Zod schema                                             | ✅ ✔️ |     |     |     |
+| [require-schema-suffix](docs/rules/require-schema-suffix.md)                             | Require schema suffix when declaring a Zod schema                                             |       |     |     | ❌  |
 | [schema-error-property-style](docs/rules/schema-error-property-style.md)                 | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns) |       |     |     |     |
 
 ### `zod` exclusive rules
 
-| Name                                                                               | Description                                                                                                              | 💼  | 🔧  | 💡  | ❌  |
-| :--------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
-| [array-style](docs/rules/array-style.md)                                           | Enforce consistent Zod array style                                                                                       | ✅  | 🔧  |     |     |
-| [no-number-schema-with-int](docs/rules/no-number-schema-with-int.md)               | Disallow usage of `z.number().int()` as it is considered legacy                                                          | ✅  | 🔧  |     |     |
-| [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md) | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                | ✅  | 🔧  |     |     |
-| [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)             | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                        | ✅  | 🔧  |     |     |
-| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                             | Disallow throwing errors directly inside Zod refine callbacks                                                            | ✅  |     |     |     |
-| [no-transform-in-record-key](docs/rules/no-transform-in-record-key.md)             | Disallow transforms in z.record() key schemas, which can cause silent key mutations and data loss through key collisions |     |     |     |     |
-| [prefer-enum-over-literal-union](docs/rules/prefer-enum-over-literal-union.md)     | Prefer `z.enum()` over `z.union()` when all members are string literals.                                                 | ✅  | 🔧  |     |     |
-| [prefer-meta-last](docs/rules/prefer-meta-last.md)                                 | Enforce `.meta()` as last method                                                                                         | ✅  | 🔧  |     |     |
-| [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)     | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                            | ✅  | 🔧  |     |     |
+| Name                                                                               | Description                                                                                                                    | 💼  | 🔧  | 💡  | ❌  |
+| :--------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [array-style](docs/rules/array-style.md)                                           | Enforce consistent Zod array style                                                                                             | ✅  | 🔧  |     |     |
+| [no-number-schema-with-finite](docs/rules/no-number-schema-with-finite.md)         | Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op. | ✅  | 🔧  |     |     |
+| [no-number-schema-with-int](docs/rules/no-number-schema-with-int.md)               | Disallow usage of `z.number().int()` as it is considered legacy                                                                | ✅  | 🔧  |     |     |
+| [no-number-schema-with-is-finite](docs/rules/no-number-schema-with-is-finite.md)   | Disallow using deprecated `isFinite` on a Zod number schema; in v4+ it is always `true`.                                       | ✅  |     |     |     |
+| [no-number-schema-with-is-int](docs/rules/no-number-schema-with-is-int.md)         | Disallow using deprecated `isInt` on a Zod number schema; check the `format` property instead.                                 | ✅  |     |     |     |
+| [no-number-schema-with-safe](docs/rules/no-number-schema-with-safe.md)             | Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`.                                | ✅  | 🔧  |     |     |
+| [no-number-schema-with-step](docs/rules/no-number-schema-with-step.md)             | Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead.                                                          | ✅  | 🔧  |     |     |
+| [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md) | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                      | ✅  | 🔧  |     |     |
+| [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)             | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                              | ✅  | 🔧  |     |     |
+| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                             | Disallow throwing errors directly inside Zod refine callbacks                                                                  | ✅  |     |     |     |
+| [no-transform-in-record-key](docs/rules/no-transform-in-record-key.md)             | Disallow transforms in z.record() key schemas, which can cause silent key mutations and data loss through key collisions       |     |     |     |     |
+| [prefer-enum-over-literal-union](docs/rules/prefer-enum-over-literal-union.md)     | Prefer `z.enum()` over `z.union()` when all members are string literals.                                                       | ✅  | 🔧  |     |     |
+| [prefer-meta-last](docs/rules/prefer-meta-last.md)                                 | Enforce `.meta()` as last method                                                                                               | ✅  | 🔧  |     |     |
+| [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)     | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                                  | ✅  | 🔧  |     |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/index.cjs

@@ -3,10 +3,16 @@ const require_array_style = require("./rules/array-style.cjs");
 const require_consistent_import_source = require("./rules/consistent-import-source.cjs");
 const require_consistent_import = require("./rules/consistent-import.cjs");
 const require_consistent_object_schema_type = require("./rules/consistent-object-schema-type.cjs");
+const require_consistent_schema_name = require("./rules/consistent-schema-name.cjs");
 const require_consistent_schema_output_type_style = require("./rules/consistent-schema-output-type-style.cjs");
 const require_no_any_schema = require("./rules/no-any-schema.cjs");
 const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_number_schema_with_finite = require("./rules/no-number-schema-with-finite.cjs");
 const require_no_number_schema_with_int = require("./rules/no-number-schema-with-int.cjs");
+const require_no_number_schema_with_is_finite = require("./rules/no-number-schema-with-is-finite.cjs");
+const require_no_number_schema_with_is_int = require("./rules/no-number-schema-with-is-int.cjs");
+const require_no_number_schema_with_safe = require("./rules/no-number-schema-with-safe.cjs");
+const require_no_number_schema_with_step = require("./rules/no-number-schema-with-step.cjs");
 const require_no_optional_and_default_together = require("./rules/no-optional-and-default-together.cjs");
 const require_no_string_schema_with_uuid = require("./rules/no-string-schema-with-uuid.cjs");
 const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
@@ -32,10 +38,16 @@ const eslintPluginZod = {
 		"consistent-import-source": require_consistent_import_source.consistentImportSource,
 		"consistent-import": require_consistent_import.consistentImport,
 		"consistent-object-schema-type": require_consistent_object_schema_type.consistentObjectSchemaType,
+		"consistent-schema-name": require_consistent_schema_name.consistentSchemaName,
 		"consistent-schema-output-type-style": require_consistent_schema_output_type_style.consistentSchemaOutputTypeStyle,
 		"no-any-schema": require_no_any_schema.noAnySchema,
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-number-schema-with-finite": require_no_number_schema_with_finite.noNumberSchemaWithFinite,
 		"no-number-schema-with-int": require_no_number_schema_with_int.noNumberSchemaWithInt,
+		"no-number-schema-with-is-finite": require_no_number_schema_with_is_finite.noNumberSchemaWithIsFinite,
+		"no-number-schema-with-is-int": require_no_number_schema_with_is_int.noNumberSchemaWithIsInt,
+		"no-number-schema-with-safe": require_no_number_schema_with_safe.noNumberSchemaWithSafe,
+		"no-number-schema-with-step": require_no_number_schema_with_step.noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": require_no_string_schema_with_uuid.noStringSchemaWithUuid,
 		"no-optional-and-default-together": require_no_optional_and_default_together.noOptionalAndDefaultTogether,
 		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
@@ -62,9 +74,15 @@ const recommendedConfig = {
 	rules: {
 		"zod/array-style": "error",
 		"zod/consistent-import": "error",
+		"zod/consistent-schema-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/no-empty-custom-schema": "error",
+		"zod/no-number-schema-with-finite": "error",
 		"zod/no-number-schema-with-int": "error",
+		"zod/no-number-schema-with-is-finite": "error",
+		"zod/no-number-schema-with-is-int": "error",
+		"zod/no-number-schema-with-safe": "error",
+		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
 		"zod/no-throw-in-refine": "error",
@@ -73,18 +91,17 @@ const recommendedConfig = {
 		"zod/prefer-meta-last": "error",
 		"zod/prefer-string-schema-with-trim": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 const recommendedConfigMini = {
 	...baseConfig,
 	rules: {
+		"zod/consistent-schema-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/prefer-meta": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 var src_default = {

package/dist/index.mjs

@@ -3,10 +3,16 @@ import { arrayStyle } from "./rules/array-style.mjs";
 import { consistentImportSource } from "./rules/consistent-import-source.mjs";
 import { consistentImport } from "./rules/consistent-import.mjs";
 import { consistentObjectSchemaType } from "./rules/consistent-object-schema-type.mjs";
+import { consistentSchemaName } from "./rules/consistent-schema-name.mjs";
 import { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-output-type-style.mjs";
 import { noAnySchema } from "./rules/no-any-schema.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noNumberSchemaWithFinite } from "./rules/no-number-schema-with-finite.mjs";
 import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.mjs";
+import { noNumberSchemaWithIsFinite } from "./rules/no-number-schema-with-is-finite.mjs";
+import { noNumberSchemaWithIsInt } from "./rules/no-number-schema-with-is-int.mjs";
+import { noNumberSchemaWithSafe } from "./rules/no-number-schema-with-safe.mjs";
+import { noNumberSchemaWithStep } from "./rules/no-number-schema-with-step.mjs";
 import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.mjs";
 import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.mjs";
 import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
@@ -32,10 +38,16 @@ const eslintPluginZod = {
 		"consistent-import-source": consistentImportSource,
 		"consistent-import": consistentImport,
 		"consistent-object-schema-type": consistentObjectSchemaType,
+		"consistent-schema-name": consistentSchemaName,
 		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle,
 		"no-any-schema": noAnySchema,
 		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-number-schema-with-finite": noNumberSchemaWithFinite,
 		"no-number-schema-with-int": noNumberSchemaWithInt,
+		"no-number-schema-with-is-finite": noNumberSchemaWithIsFinite,
+		"no-number-schema-with-is-int": noNumberSchemaWithIsInt,
+		"no-number-schema-with-safe": noNumberSchemaWithSafe,
+		"no-number-schema-with-step": noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": noStringSchemaWithUuid,
 		"no-optional-and-default-together": noOptionalAndDefaultTogether,
 		"no-throw-in-refine": noThrowInRefine,
@@ -62,9 +74,15 @@ const recommendedConfig = {
 	rules: {
 		"zod/array-style": "error",
 		"zod/consistent-import": "error",
+		"zod/consistent-schema-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/no-empty-custom-schema": "error",
+		"zod/no-number-schema-with-finite": "error",
 		"zod/no-number-schema-with-int": "error",
+		"zod/no-number-schema-with-is-finite": "error",
+		"zod/no-number-schema-with-is-int": "error",
+		"zod/no-number-schema-with-safe": "error",
+		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
 		"zod/no-throw-in-refine": "error",
@@ -73,18 +91,17 @@ const recommendedConfig = {
 		"zod/prefer-meta-last": "error",
 		"zod/prefer-string-schema-with-trim": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 const recommendedConfigMini = {
 	...baseConfig,
 	rules: {
+		"zod/consistent-schema-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/prefer-meta": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 var src_default = {

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

@@ -0,0 +1,76 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/consistent-schema-name.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const consistentSchemaName = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-schema-name",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce a consistent naming convention for Zod schema variables"
+		},
+		messages: { invalidName: "Rename this Zod schema to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: {
+				before: {
+					type: "string",
+					description: "The required prefix for Zod schema variables"
+				},
+				after: {
+					type: "string",
+					description: "The required suffix for Zod 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.consistentSchemaName = consistentSchemaName;

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

@@ -0,0 +1,75 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-schema-name.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const consistentSchemaName = createZodPluginRule({
+	name: "consistent-schema-name",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce a consistent naming convention for Zod schema variables"
+		},
+		messages: { invalidName: "Rename this Zod schema to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: {
+				before: {
+					type: "string",
+					description: "The required prefix for Zod schema variables"
+				},
+				after: {
+					type: "string",
+					description: "The required suffix for Zod 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 { consistentSchemaName };

package/dist/rules/no-number-schema-with-finite.cjs

@@ -0,0 +1,44 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+const require_build_zod_chain_remove_method_fix = require("../utils/build-zod-chain-remove-method-fix.cjs");
+//#region src/rules/no-number-schema-with-finite.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noNumberSchemaWithFinite = require_create_plugin_rule.createZodPluginRule({
+	name: "no-number-schema-with-finite",
+	meta: {
+		fixable: "code",
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op."
+		},
+		messages: { removeFinite: "`.finite()` is deprecated. In Zod 4+ `z.number()` does not allow infinite values by default. Remove this call." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "number") return;
+				const methods = collectZodChainMethods(node);
+				const finiteIndex = methods.findIndex((m) => m.name === "finite" && m.node === node);
+				if (finiteIndex === -1) return;
+				context.report({
+					node,
+					messageId: "removeFinite",
+					fix(fixer) {
+						return require_build_zod_chain_remove_method_fix.buildZodChainRemoveMethodFix({
+							fixer,
+							methods,
+							removeIndex: finiteIndex
+						});
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noNumberSchemaWithFinite = noNumberSchemaWithFinite;

package/dist/rules/no-number-schema-with-finite.mjs

@@ -0,0 +1,44 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { buildZodChainRemoveMethodFix } from "../utils/build-zod-chain-remove-method-fix.mjs";
+//#region src/rules/no-number-schema-with-finite.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const noNumberSchemaWithFinite = createZodPluginRule({
+	name: "no-number-schema-with-finite",
+	meta: {
+		fixable: "code",
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op."
+		},
+		messages: { removeFinite: "`.finite()` is deprecated. In Zod 4+ `z.number()` does not allow infinite values by default. Remove this call." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "number") return;
+				const methods = collectZodChainMethods(node);
+				const finiteIndex = methods.findIndex((m) => m.name === "finite" && m.node === node);
+				if (finiteIndex === -1) return;
+				context.report({
+					node,
+					messageId: "removeFinite",
+					fix(fixer) {
+						return buildZodChainRemoveMethodFix({
+							fixer,
+							methods,
+							removeIndex: finiteIndex
+						});
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNumberSchemaWithFinite };

package/dist/rules/no-number-schema-with-is-finite.cjs

@@ -0,0 +1,38 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/no-number-schema-with-is-finite.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noNumberSchemaWithIsFinite = require_create_plugin_rule.createZodPluginRule({
+	name: "no-number-schema-with-is-finite",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow using deprecated `isFinite` on a Zod number schema; in v4+ it is always `true`."
+		},
+		messages: { deprecated: "`isFinite` is deprecated. Number schemas no longer accept infinite values, so this is always `true` for `z.number()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			MemberExpression(node) {
+				if (node.computed) return;
+				if (node.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+				if (node.property.name !== "isFinite") return;
+				if (node.object.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+				if (!isZodNumberSchemaCallExpression(node.object)) return;
+				context.report({
+					node,
+					messageId: "deprecated"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noNumberSchemaWithIsFinite = noNumberSchemaWithIsFinite;

package/dist/rules/no-number-schema-with-is-finite.mjs

@@ -0,0 +1,37 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/no-number-schema-with-is-finite.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const noNumberSchemaWithIsFinite = createZodPluginRule({
+	name: "no-number-schema-with-is-finite",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow using deprecated `isFinite` on a Zod number schema; in v4+ it is always `true`."
+		},
+		messages: { deprecated: "`isFinite` is deprecated. Number schemas no longer accept infinite values, so this is always `true` for `z.number()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			MemberExpression(node) {
+				if (node.computed) return;
+				if (node.property.type !== AST_NODE_TYPES.Identifier) return;
+				if (node.property.name !== "isFinite") return;
+				if (node.object.type !== AST_NODE_TYPES.CallExpression) return;
+				if (!isZodNumberSchemaCallExpression(node.object)) return;
+				context.report({
+					node,
+					messageId: "deprecated"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNumberSchemaWithIsFinite };

package/dist/rules/no-number-schema-with-is-int.cjs

@@ -0,0 +1,38 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/no-number-schema-with-is-int.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noNumberSchemaWithIsInt = require_create_plugin_rule.createZodPluginRule({
+	name: "no-number-schema-with-is-int",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow using deprecated `isInt` on a Zod number schema; check the `format` property instead."
+		},
+		messages: { useFormat: "`isInt` is deprecated. Check the `format` property on the number schema instead (or compare to `\"int\"` or `\"float\"`)." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			MemberExpression(node) {
+				if (node.computed) return;
+				if (node.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+				if (node.property.name !== "isInt") return;
+				if (node.object.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+				if (!isZodNumberSchemaCallExpression(node.object)) return;
+				context.report({
+					node,
+					messageId: "useFormat"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noNumberSchemaWithIsInt = noNumberSchemaWithIsInt;

package/dist/rules/no-number-schema-with-is-int.mjs

@@ -0,0 +1,37 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/no-number-schema-with-is-int.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const noNumberSchemaWithIsInt = createZodPluginRule({
+	name: "no-number-schema-with-is-int",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow using deprecated `isInt` on a Zod number schema; check the `format` property instead."
+		},
+		messages: { useFormat: "`isInt` is deprecated. Check the `format` property on the number schema instead (or compare to `\"int\"` or `\"float\"`)." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			MemberExpression(node) {
+				if (node.computed) return;
+				if (node.property.type !== AST_NODE_TYPES.Identifier) return;
+				if (node.property.name !== "isInt") return;
+				if (node.object.type !== AST_NODE_TYPES.CallExpression) return;
+				if (!isZodNumberSchemaCallExpression(node.object)) return;
+				context.report({
+					node,
+					messageId: "useFormat"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNumberSchemaWithIsInt };

package/dist/rules/no-number-schema-with-safe.cjs

@@ -0,0 +1,57 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+const require_build_zod_chain_replacement_fix = require("../utils/build-zod-chain-replacement-fix.cjs");
+//#region src/rules/no-number-schema-with-safe.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noNumberSchemaWithSafe = require_create_plugin_rule.createZodPluginRule({
+	name: "no-number-schema-with-safe",
+	meta: {
+		fixable: "code",
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`."
+		},
+		messages: { useInt: "`.safe()` is deprecated; it is identical to `.int()`. Use `z.int()` (or the equivalent) instead of chaining `.safe()` on `z.number()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "number") return;
+				const methods = collectZodChainMethods(node);
+				const safeIndex = methods.findIndex((m) => m.name === "safe" && m.node === node);
+				if (safeIndex === -1) return;
+				const numberIndex = methods.findIndex((m) => m.name === "number");
+				if (zodSchemaMeta.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "useInt"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useInt",
+					fix(fixer) {
+						return require_build_zod_chain_replacement_fix.buildZodChainReplacementFix({
+							sourceCode,
+							fixer,
+							methods,
+							fromIndex: numberIndex,
+							toIndex: safeIndex,
+							toMethodName: "int"
+						});
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noNumberSchemaWithSafe = noNumberSchemaWithSafe;

package/dist/rules/no-number-schema-with-safe.mjs

@@ -0,0 +1,57 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { buildZodChainReplacementFix } from "../utils/build-zod-chain-replacement-fix.mjs";
+//#region src/rules/no-number-schema-with-safe.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const noNumberSchemaWithSafe = createZodPluginRule({
+	name: "no-number-schema-with-safe",
+	meta: {
+		fixable: "code",
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`."
+		},
+		messages: { useInt: "`.safe()` is deprecated; it is identical to `.int()`. Use `z.int()` (or the equivalent) instead of chaining `.safe()` on `z.number()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "number") return;
+				const methods = collectZodChainMethods(node);
+				const safeIndex = methods.findIndex((m) => m.name === "safe" && m.node === node);
+				if (safeIndex === -1) return;
+				const numberIndex = methods.findIndex((m) => m.name === "number");
+				if (zodSchemaMeta.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "useInt"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useInt",
+					fix(fixer) {
+						return buildZodChainReplacementFix({
+							sourceCode,
+							fixer,
+							methods,
+							fromIndex: numberIndex,
+							toIndex: safeIndex,
+							toMethodName: "int"
+						});
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNumberSchemaWithSafe };

package/dist/rules/no-number-schema-with-step.cjs

@@ -0,0 +1,43 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/no-number-schema-with-step.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noNumberSchemaWithStep = require_create_plugin_rule.createZodPluginRule({
+	name: "no-number-schema-with-step",
+	meta: {
+		fixable: "code",
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead."
+		},
+		messages: { useMultipleOf: "`.step()` is deprecated. Use `.multipleOf()` with the same argument instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "number") return;
+				if (collectZodChainMethods(node).findIndex((m) => m.name === "step" && m.node === node) === -1) return;
+				const { callee } = node;
+				if (callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+				if (callee.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+				const { property } = callee;
+				context.report({
+					node,
+					messageId: "useMultipleOf",
+					fix(fixer) {
+						return fixer.replaceText(property, "multipleOf");
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noNumberSchemaWithStep = noNumberSchemaWithStep;

package/dist/rules/no-number-schema-with-step.mjs

@@ -0,0 +1,42 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/no-number-schema-with-step.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const noNumberSchemaWithStep = createZodPluginRule({
+	name: "no-number-schema-with-step",
+	meta: {
+		fixable: "code",
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead."
+		},
+		messages: { useMultipleOf: "`.step()` is deprecated. Use `.multipleOf()` with the same argument instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "number") return;
+				if (collectZodChainMethods(node).findIndex((m) => m.name === "step" && m.node === node) === -1) return;
+				const { callee } = node;
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
+				if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
+				const { property } = callee;
+				context.report({
+					node,
+					messageId: "useMultipleOf",
+					fix(fixer) {
+						return fixer.replaceText(property, "multipleOf");
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNumberSchemaWithStep };

package/dist/rules/require-schema-suffix.cjs

@@ -8,6 +8,7 @@ const requireSchemaSuffix = require_create_plugin_rule.createZodPluginRule({
 	name: "require-schema-suffix",
 	meta: {
 		type: "suggestion",
+		deprecated: { message: "Use `zod/consistent-schema-name`" },
 		docs: {
 			zodImportAllowedSource,
 			description: "Require schema suffix when declaring a Zod schema"

package/dist/rules/require-schema-suffix.mjs

@@ -7,6 +7,7 @@ const requireSchemaSuffix = createZodPluginRule({
 	name: "require-schema-suffix",
 	meta: {
 		type: "suggestion",
+		deprecated: { message: "Use `zod/consistent-schema-name`" },
 		docs: {
 			zodImportAllowedSource,
 			description: "Require schema suffix when declaring a Zod schema"

package/dist/utils/build-zod-chain-remove-method-fix.cjs

@@ -0,0 +1,15 @@
+//#region src/utils/build-zod-chain-remove-method-fix.ts
+/**
+* Remove one call from a zod method chain, e.g. `z.number().min(0).finite()` →
+* `z.number().min(0)`.
+*/
+function buildZodChainRemoveMethodFix(opts) {
+	const { fixer, methods, removeIndex } = opts;
+	if (removeIndex < 1) return null;
+	const prev = methods[removeIndex - 1]?.node;
+	const toRemove = methods[removeIndex]?.node;
+	if (!prev?.range || !toRemove?.range) return null;
+	return fixer.removeRange([prev.range[1], toRemove.range[1]]);
+}
+//#endregion
+exports.buildZodChainRemoveMethodFix = buildZodChainRemoveMethodFix;

package/dist/utils/build-zod-chain-remove-method-fix.mjs

@@ -0,0 +1,15 @@
+//#region src/utils/build-zod-chain-remove-method-fix.ts
+/**
+* Remove one call from a zod method chain, e.g. `z.number().min(0).finite()` →
+* `z.number().min(0)`.
+*/
+function buildZodChainRemoveMethodFix(opts) {
+	const { fixer, methods, removeIndex } = opts;
+	if (removeIndex < 1) return null;
+	const prev = methods[removeIndex - 1]?.node;
+	const toRemove = methods[removeIndex]?.node;
+	if (!prev?.range || !toRemove?.range) return null;
+	return fixer.removeRange([prev.range[1], toRemove.range[1]]);
+}
+//#endregion
+export { buildZodChainRemoveMethodFix };

package/dist/utils/detect-zod-schema-root-node.cjs

@@ -71,6 +71,16 @@ function parseZodCallExpression(call, zodNamespaces, zodNamedImports) {
 	};
 	return null;
 }
+/**
+* True when `node` is a zod number schema call chain (e.g. `z.number().min(1)`) or `number().min(1)`.
+* Used for member access like `z.number().isInt` where the call is not the outermost expression
+* in the file (so {@link detectZodSchemaRootNode} does not apply).
+*/
+function isZodNumberSchemaCallExpression(node, zodNamespaces, zodNamedImports) {
+	if (node.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
+	const parsed = parseZodCallExpression(node, zodNamespaces, zodNamedImports);
+	return parsed !== null && parsed.schemaType === "number";
+}
 /** Examine an expression (argument) for zod schema CallExpressions.
 * Supports:
 *  - direct CallExpression (string(), z.string(), etc)
@@ -100,3 +110,4 @@ function detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports) {
 }
 //#endregion
 exports.detectZodSchemaRootNode = detectZodSchemaRootNode;
+exports.isZodNumberSchemaCallExpression = isZodNumberSchemaCallExpression;

package/dist/utils/detect-zod-schema-root-node.mjs

@@ -70,6 +70,16 @@ function parseZodCallExpression(call, zodNamespaces, zodNamedImports) {
 	};
 	return null;
 }
+/**
+* True when `node` is a zod number schema call chain (e.g. `z.number().min(1)`) or `number().min(1)`.
+* Used for member access like `z.number().isInt` where the call is not the outermost expression
+* in the file (so {@link detectZodSchemaRootNode} does not apply).
+*/
+function isZodNumberSchemaCallExpression(node, zodNamespaces, zodNamedImports) {
+	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
+	const parsed = parseZodCallExpression(node, zodNamespaces, zodNamedImports);
+	return parsed !== null && parsed.schemaType === "number";
+}
 /** Examine an expression (argument) for zod schema CallExpressions.
 * Supports:
 *  - direct CallExpression (string(), z.string(), etc)
@@ -98,4 +108,4 @@ function detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports) {
 	};
 }
 //#endregion
-export { detectZodSchemaRootNode };
+export { detectZodSchemaRootNode, isZodNumberSchemaCallExpression };

package/dist/utils/track-zod-schema-imports.cjs

@@ -58,7 +58,8 @@ function trackZodSchemaImports(importAllowedSource) {
 		getNamedImportOriginal: (localName) => zodNamedImports.get(localName),
 		getNamedImportLocal: (originalName) => zodNamedImportsByOriginal.get(originalName),
 		detectZodSchemaRootNode: (node) => require_detect_zod_schema_root_node.detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports),
-		collectZodChainMethods
+		collectZodChainMethods,
+		isZodNumberSchemaCallExpression: (node) => require_detect_zod_schema_root_node.isZodNumberSchemaCallExpression(node, zodNamespaces, zodNamedImports)
 	};
 }
 /**

package/dist/utils/track-zod-schema-imports.mjs

@@ -1,4 +1,4 @@
-import { detectZodSchemaRootNode } from "./detect-zod-schema-root-node.mjs";
+import { detectZodSchemaRootNode, isZodNumberSchemaCallExpression } from "./detect-zod-schema-root-node.mjs";
 import { isZodImportSource } from "./is-zod-import-source.mjs";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 //#region src/utils/track-zod-schema-imports.ts
@@ -57,7 +57,8 @@ function trackZodSchemaImports(importAllowedSource) {
 		getNamedImportOriginal: (localName) => zodNamedImports.get(localName),
 		getNamedImportLocal: (originalName) => zodNamedImportsByOriginal.get(originalName),
 		detectZodSchemaRootNode: (node) => detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports),
-		collectZodChainMethods
+		collectZodChainMethods,
+		isZodNumberSchemaCallExpression: (node) => isZodNumberSchemaCallExpression(node, zodNamespaces, zodNamedImports)
 	};
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "type": "module",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "engines": {