eslint-plugin-zod 4.0.0 → 4.1.0

package/README.md

@@ -29,37 +29,39 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 💼 Configurations enabled in.\
 ✅ Set in the `recommended` configuration.\
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
-💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
-
-| Name                                                                                             | Description                                                                                                                    | 💼  | 🔧  | 💡  |
-| :----------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- |
-| [array-style](docs/rules/array-style.md)                                                         | Enforce consistent Zod array style                                                                                             | ✅  | 🔧  |     |
-| [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-output-type-style](docs/rules/consistent-schema-output-type-style.md)         | Enforce consistent use of z.infer or z.output for schema type inference                                                        |     | 🔧  |     |
-| [consistent-schema-var-name](docs/rules/consistent-schema-var-name.md)                           | Enforce a consistent naming convention for Zod schema variables                                                                | ✅  |     |     |
-| [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                                                                               | ✅  |     |     |
-| [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       |     |     |     |
-| [no-unknown-schema](docs/rules/no-unknown-schema.md)                                             | Disallow usage of `z.unknown()` in Zod schemas                                                                                 |     |     |     |
-| [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](docs/rules/prefer-meta.md)                                                         | Enforce usage of `.meta()` over `.describe()`                                                                                  | ✅  | 🔧  |     |
-| [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                                                  | ✅  | 🔧  |     |
-| [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |
-| [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                                                                       | ✅  | 🔧  |     |
-| [schema-error-property-style](docs/rules/schema-error-property-style.md)                         | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)                                  |     |     |     |
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
+❌ Deprecated.
+
+| Name                                                                                             | Description                                                                                                                    | 💼  | 🔧  | 💡  | ❌  |
+| :----------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [array-style](docs/rules/array-style.md)                                                         | Enforce consistent Zod array style                                                                                             | ✅  | 🔧  |     |     |
+| [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-output-type-style](docs/rules/consistent-schema-output-type-style.md)         | Enforce consistent use of z.infer or z.output for schema type inference                                                        |     | 🔧  |     |     |
+| [consistent-schema-var-name](docs/rules/consistent-schema-var-name.md)                           | Enforce a consistent naming convention for Zod schema variables                                                                | ✅  |     |     |     |
+| [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                                                                               | ✅  |     |     |     |
+| [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       |     |     |     |     |
+| [no-unknown-schema](docs/rules/no-unknown-schema.md)                                             | Disallow usage of `z.unknown()` in Zod schemas                                                                                 |     |     |     |     |
+| [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](docs/rules/prefer-meta.md)                                                         | Enforce usage of `.meta()` over `.describe()`                                                                                  | ✅  | 🔧  |     |     |
+| [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                                                  | ✅  | 🔧  |     |     |
+| [prefer-top-level-string-formats](docs/rules/prefer-top-level-string-formats.md)                 | Prefer top-level string format schemas over deprecated `z.string().<format>()` methods                                         | ✅  | 🔧  |     |     |
+| [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |     |
+| [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                                                                       | ✅  | 🔧  |     |     |
+| [schema-error-property-style](docs/rules/schema-error-property-style.md)                         | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)                                  |     |     |     |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -0,0 +1,105 @@
+const require_meta = require("./meta.cjs");
+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_output_type_style = require("./rules/consistent-schema-output-type-style.cjs");
+const require_consistent_schema_var_name = require("./rules/consistent-schema-var-name.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");
+const require_no_transform_in_record_key = require("./rules/no-transform-in-record-key.cjs");
+const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
+const require_prefer_enum_over_literal_union = require("./rules/prefer-enum-over-literal-union.cjs");
+const require_prefer_meta_last = require("./rules/prefer-meta-last.cjs");
+const require_prefer_meta = require("./rules/prefer-meta.cjs");
+const require_prefer_string_schema_with_trim = require("./rules/prefer-string-schema-with-trim.cjs");
+const require_prefer_top_level_string_formats = require("./rules/prefer-top-level-string-formats.cjs");
+const require_prefer_trim_before_string_length_checks = require("./rules/prefer-trim-before-string-length-checks.cjs");
+const require_require_brand_type_parameter = require("./rules/require-brand-type-parameter.cjs");
+const require_require_error_message = require("./rules/require-error-message.cjs");
+const require_schema_error_property_style = require("./rules/schema-error-property-style.cjs");
+//#region src/index.ts
+const eslintPluginZod = {
+	meta: {
+		name: require_meta.PLUGIN_NAME,
+		version: require_meta.PLUGIN_VERSION
+	},
+	rules: {
+		"array-style": require_array_style.arrayStyle,
+		"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-var-name": require_consistent_schema_var_name.consistentSchemaVarName,
+		"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,
+		"no-transform-in-record-key": require_no_transform_in_record_key.noTransformInRecordKey,
+		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
+		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
+		"prefer-meta": require_prefer_meta.preferMeta,
+		"prefer-meta-last": require_prefer_meta_last.preferMetaLast,
+		"prefer-top-level-string-formats": require_prefer_top_level_string_formats.preferTopLevelStringFormats,
+		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
+		"prefer-trim-before-string-length-checks": require_prefer_trim_before_string_length_checks.preferTrimBeforeStringLengthChecks,
+		"require-brand-type-parameter": require_require_brand_type_parameter.requireBrandTypeParameter,
+		"require-error-message": require_require_error_message.requireErrorMessage,
+		"schema-error-property-style": require_schema_error_property_style.schemaErrorPropertyStyle
+	}
+};
+const recommendedConfig = {
+	name: `${require_meta.PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { zod: eslintPluginZod },
+	rules: {
+		"zod/array-style": "error",
+		"zod/consistent-import": "error",
+		"zod/consistent-schema-var-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",
+		"zod/prefer-enum-over-literal-union": "error",
+		"zod/prefer-meta": "error",
+		"zod/prefer-meta-last": "error",
+		"zod/prefer-top-level-string-formats": "error",
+		"zod/prefer-string-schema-with-trim": "error",
+		"zod/prefer-trim-before-string-length-checks": "error",
+		"zod/require-brand-type-parameter": "error",
+		"zod/require-error-message": "error"
+	}
+};
+var src_default = {
+	...eslintPluginZod,
+	configs: { recommended: recommendedConfig }
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-zod/issues/49
+*/
+//#endregion
+module.exports = src_default;

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+//#region src/index.d.ts
+interface CompatibleConfig {
+  name?: string;
+  rules?: object;
+  plugins?: Record<string, CompatiblePlugin>;
+}
+interface CompatiblePlugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+}
+declare const _default: {
+  configs: {
+    recommended: CompatibleConfig;
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+};
+export = _default;

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+//#region src/index.d.ts
+interface CompatibleConfig {
+  name?: string;
+  rules?: object;
+  plugins?: Record<string, CompatiblePlugin>;
+}
+interface CompatiblePlugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+}
+declare const _default: {
+  configs: {
+    recommended: CompatibleConfig;
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+};
+//#endregion
+export { _default as default };

package/dist/index.mjs

@@ -0,0 +1,105 @@
+import { PLUGIN_NAME, PLUGIN_VERSION } from "./meta.mjs";
+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 { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-output-type-style.mjs";
+import { consistentSchemaVarName } from "./rules/consistent-schema-var-name.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";
+import { noTransformInRecordKey } from "./rules/no-transform-in-record-key.mjs";
+import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
+import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
+import { preferMetaLast } from "./rules/prefer-meta-last.mjs";
+import { preferMeta } from "./rules/prefer-meta.mjs";
+import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.mjs";
+import { preferTopLevelStringFormats } from "./rules/prefer-top-level-string-formats.mjs";
+import { preferTrimBeforeStringLengthChecks } from "./rules/prefer-trim-before-string-length-checks.mjs";
+import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.mjs";
+import { requireErrorMessage } from "./rules/require-error-message.mjs";
+import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.mjs";
+//#region src/index.ts
+const eslintPluginZod = {
+	meta: {
+		name: PLUGIN_NAME,
+		version: PLUGIN_VERSION
+	},
+	rules: {
+		"array-style": arrayStyle,
+		"consistent-import-source": consistentImportSource,
+		"consistent-import": consistentImport,
+		"consistent-object-schema-type": consistentObjectSchemaType,
+		"consistent-schema-var-name": consistentSchemaVarName,
+		"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,
+		"no-transform-in-record-key": noTransformInRecordKey,
+		"no-unknown-schema": noUnknownSchema,
+		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
+		"prefer-meta": preferMeta,
+		"prefer-meta-last": preferMetaLast,
+		"prefer-top-level-string-formats": preferTopLevelStringFormats,
+		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
+		"prefer-trim-before-string-length-checks": preferTrimBeforeStringLengthChecks,
+		"require-brand-type-parameter": requireBrandTypeParameter,
+		"require-error-message": requireErrorMessage,
+		"schema-error-property-style": schemaErrorPropertyStyle
+	}
+};
+const recommendedConfig = {
+	name: `${PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { zod: eslintPluginZod },
+	rules: {
+		"zod/array-style": "error",
+		"zod/consistent-import": "error",
+		"zod/consistent-schema-var-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",
+		"zod/prefer-enum-over-literal-union": "error",
+		"zod/prefer-meta": "error",
+		"zod/prefer-meta-last": "error",
+		"zod/prefer-top-level-string-formats": "error",
+		"zod/prefer-string-schema-with-trim": "error",
+		"zod/prefer-trim-before-string-length-checks": "error",
+		"zod/require-brand-type-parameter": "error",
+		"zod/require-error-message": "error"
+	}
+};
+var src_default = {
+	...eslintPluginZod,
+	configs: { recommended: recommendedConfig }
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-zod/issues/49
+*/
+//#endregion
+export { src_default as default };

package/dist/meta.cjs

@@ -0,0 +1,11 @@
+require("./_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, repository } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+function getRuleURL(ruleID) {
+	return `${repository.url}/blob/HEAD/${repository.directory}/docs/rules/${ruleID}.md`;
+}
+//#endregion
+exports.PLUGIN_NAME = PLUGIN_NAME;
+exports.PLUGIN_VERSION = PLUGIN_VERSION;
+exports.getRuleURL = getRuleURL;

package/dist/meta.mjs

@@ -0,0 +1,8 @@
+import { readFileSync } from "node:fs";
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, repository } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+function getRuleURL(ruleID) {
+	return `${repository.url}/blob/HEAD/${repository.directory}/docs/rules/${ruleID}.md`;
+}
+//#endregion
+export { PLUGIN_NAME, PLUGIN_VERSION, getRuleURL };

package/dist/rules/array-style.cjs

@@ -0,0 +1,87 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/array-style.ts
+const ZOD_ARRAY_STYLES = ["function", "method"];
+const defaultOptions = { style: "function" };
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const arrayStyle = require_create_plugin_rule.createZodPluginRule({
+	name: "array-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Enforce consistent Zod array style" },
+		messages: {
+			useFunction: "Use z.array(schema) instead of schema.array().",
+			useMethod: "Use schema.array() instead of z.array(schema)."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style for zod array function",
+				type: "string",
+				enum: ZOD_ARRAY_STYLES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ style }]) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchema = detectZodSchemaRootNode(node);
+				if (!zodSchema) return;
+				const { schemaDecl, schemaType } = zodSchema;
+				if (style === "method") {
+					if (schemaType === "array") {
+						if (schemaDecl === "namespace") {
+							context.report({
+								node,
+								messageId: "useMethod",
+								fix(fixer) {
+									const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
+									if (!arrayCall) return null;
+									const arg = arrayCall.node.arguments.at(0);
+									if (!arg) return null;
+									const argText = sourceCode.getText(arg);
+									return fixer.replaceText(arrayCall.node, `${argText}.array()`);
+								}
+							});
+							return;
+						}
+						context.report({
+							node,
+							messageId: "useMethod"
+						});
+					}
+					return;
+				}
+				const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
+				if (arrayMethod) {
+					const arrayNode = arrayMethod.node;
+					if (schemaDecl === "namespace") {
+						context.report({
+							node,
+							messageId: "useFunction",
+							fix(fixer) {
+								const callee = arrayNode.callee;
+								const objText = sourceCode.getText(callee.object);
+								return fixer.replaceText(arrayNode, `z.array(${objText})`);
+							}
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "useFunction"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.arrayStyle = arrayStyle;

package/dist/rules/array-style.mjs

@@ -0,0 +1,86 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+//#region src/rules/array-style.ts
+const ZOD_ARRAY_STYLES = ["function", "method"];
+const defaultOptions = { style: "function" };
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const arrayStyle = createZodPluginRule({
+	name: "array-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Enforce consistent Zod array style" },
+		messages: {
+			useFunction: "Use z.array(schema) instead of schema.array().",
+			useMethod: "Use schema.array() instead of z.array(schema)."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style for zod array function",
+				type: "string",
+				enum: ZOD_ARRAY_STYLES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ style }]) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchema = detectZodSchemaRootNode(node);
+				if (!zodSchema) return;
+				const { schemaDecl, schemaType } = zodSchema;
+				if (style === "method") {
+					if (schemaType === "array") {
+						if (schemaDecl === "namespace") {
+							context.report({
+								node,
+								messageId: "useMethod",
+								fix(fixer) {
+									const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
+									if (!arrayCall) return null;
+									const arg = arrayCall.node.arguments.at(0);
+									if (!arg) return null;
+									const argText = sourceCode.getText(arg);
+									return fixer.replaceText(arrayCall.node, `${argText}.array()`);
+								}
+							});
+							return;
+						}
+						context.report({
+							node,
+							messageId: "useMethod"
+						});
+					}
+					return;
+				}
+				const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
+				if (arrayMethod) {
+					const arrayNode = arrayMethod.node;
+					if (schemaDecl === "namespace") {
+						context.report({
+							node,
+							messageId: "useFunction",
+							fix(fixer) {
+								const callee = arrayNode.callee;
+								const objText = sourceCode.getText(callee.object);
+								return fixer.replaceText(arrayNode, `z.array(${objText})`);
+							}
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "useFunction"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { arrayStyle };

package/dist/rules/consistent-import-source.cjs

@@ -0,0 +1,58 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/consistent-import-source.ts
+const consistentImportSource = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-import-source",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: { description: "Enforce consistent source from Zod imports" },
+		messages: {
+			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
+			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
+		},
+		schema: [{
+			type: "object",
+			properties: { sources: {
+				type: "array",
+				description: "An array of allowed Zod import sources.",
+				items: {
+					type: "string",
+					enum: [..._eslint_zod_utils.zodImportScope.sources]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ sources: ["zod"] }],
+	create(context, [{ sources }]) {
+		return { ImportDeclaration(node) {
+			const sourceValue = node.source.value;
+			if (!_eslint_zod_utils.zodImportScope.isAllowed(sourceValue)) return;
+			if (sources.includes(sourceValue)) return;
+			context.report({
+				node,
+				messageId: "sourceNotAllowed",
+				data: {
+					source: sourceValue,
+					sources: sources.map((s) => `"${s}"`).join(", ")
+				},
+				suggest: sources.map((it) => ({
+					messageId: "replaceSource",
+					data: {
+						valid: it,
+						invalid: sourceValue
+					},
+					fix(fixer) {
+						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
+					}
+				}))
+			});
+		} };
+	}
+});
+//#endregion
+exports.consistentImportSource = consistentImportSource;