eslint-plugin-zod 1.4.0 → 3.0.0

package/LICENSE

@@ -1,24 +1,21 @@
-Copyright (c) 2022, Gajus Kuizinas (https://gajus.com/)
-All rights reserved.
+MIT License
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the Gajus Kuizinas (https://gajus.com/) nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
+Copyright (c) 2025-present Marco Pasqualetti
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL GAJUS KUIZINAS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,88 +1,106 @@
-<a name="user-content-eslint-plugin-zod"></a>
-<a name="eslint-plugin-zod"></a>
 # eslint-plugin-zod
 
-[![Canonical Code Style](https://img.shields.io/badge/code%20style-canonical-blue.svg?style=flat-square)](https://github.com/gajus/canonical)
-[![NPM version](http://img.shields.io/npm/v/eslint-plugin-zod.svg?style=flat-square)](https://www.npmjs.org/package/eslint-plugin-zod)
-[![Twitter Follow](https://img.shields.io/twitter/follow/kuizinas.svg?style=social&label=Follow)](https://twitter.com/kuizinas)
+[![CI][CIBadge]][CIURL]
+[![Code style: prettier][CodeStyleBadge]][CodeStyleURL]
+[![Lint: eslint][lintBadge]][lintURL]
+[![npm version][npmVersionBadge]][npmVersionURL]
+[![issues][issuesBadge]][issuesURL]
+
+[CIBadge]: https://img.shields.io/github/actions/workflow/status/marcalexiei/eslint-plugin-zod/ci.yml?style=for-the-badge&logo=github&event=push&label=CI
+[CIURL]: https://github.com/marcalexiei/eslint-plugin-zod/actions/workflows/CI.yml/badge.svg
+[CodeStyleBadge]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=for-the-badge&logo=prettier
+[CodeStyleURL]: https://prettier.io
+[npmVersionBadge]: https://img.shields.io/npm/v/eslint-plugin-zod.svg?style=for-the-badge&logo=npm
+[npmVersionURL]: https://www.npmjs.com/package/eslint-plugin-zod
+[lintBadge]: https://img.shields.io/badge/lint-eslint-3A33D1?logo=eslint&style=for-the-badge
+[lintURL]: https://eslint.org
+[issuesBadge]: https://img.shields.io/github/issues/marcalexiei/eslint-plugin-zod.svg?style=for-the-badge
+[issuesURL]: https://github.com/marcalexiei/eslint-plugin-zod/issues
+
+[ESLint](https://eslint.org) plugin that adds custom linting rules to enforce best practices when using [Zod](https://github.com/colinhacks/zod)
 
-[Zod](https://github.com/colinhacks/zod) linting rules for ESLint.
-
-* [eslint-plugin-zod](#user-content-eslint-plugin-zod)
-    * [Installation](#user-content-eslint-plugin-zod-installation)
-    * [Configuration](#user-content-eslint-plugin-zod-configuration)
-    * [Rules](#user-content-eslint-plugin-zod-rules)
-        * [`prefer-enum`](#user-content-eslint-plugin-zod-rules-prefer-enum)
-        * [`require-strict`](#user-content-eslint-plugin-zod-rules-require-strict)
+## Rules
 
+<!-- begin auto-generated rules list -->
+
+💼 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-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                                                |     |     | 💡  |
+| [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-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-throw-in-refine](docs/rules/no-throw-in-refine.md)                             | Disallow throwing errors directly inside Zod refine callbacks                                 | ✅  |     |     |
+| [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-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                                             | ✅  |     |     |
+| [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 -->
 
-<a name="user-content-eslint-plugin-zod-installation"></a>
-<a name="eslint-plugin-zod-installation"></a>
 ## Installation
 
-1. Install [ESLint](https://www.github.com/eslint/eslint).
-1. Install [`eslint-plugin-zod`](https://github.com/gajus/eslint-plugin-zod) plugin.
+Install `eslint` and `eslint-plugin-zod` using your preferred package manager:
 
-<!-- -->
-
-```sh
-npm install eslint --save-dev
-npm install eslint-plugin-zod --save-dev
+```shell
+npm i --save-dev eslint eslint-plugin-zod
 ```
 
-<a name="user-content-eslint-plugin-zod-configuration"></a>
-<a name="eslint-plugin-zod-configuration"></a>
-## Configuration
-
-1. Add `plugins` section and specify `eslint-plugin-zod` as a plugin.
-1. Enable rules.
-
-<!-- -->
-
-```json
-{
-  "plugins": [
-    "zod"
-  ],
-  "rules": {
-    "zod/prefer-enum": 2,
-    "zod/require-strict": 2
-  }
-}
-
+```shell
+yarn add --dev eslint eslint-plugin-zod
 ```
 
-<a name="user-content-eslint-plugin-zod-rules"></a>
-<a name="eslint-plugin-zod-rules"></a>
-## Rules
-
-<!-- Rules are sorted alphabetically. -->
-
-<a name="user-content-eslint-plugin-zod-rules-prefer-enum"></a>
-<a name="eslint-plugin-zod-rules-prefer-enum"></a>
-### <code>prefer-enum</code>
-
-_The `--fix` option on the command line automatically fixes problems reported by this rule._
+```shell
+pnpm add --save-dev eslint eslint-plugin-zod
+```
 
-Prefers `z.enum` over a union of literals.
+## Configuration
 
+1. Import the plugin
 
+   ```ts
+   import eslintPluginZod from 'eslint-plugin-zod';
+   ```
 
-<a name="user-content-eslint-plugin-zod-rules-require-strict"></a>
-<a name="eslint-plugin-zod-rules-require-strict"></a>
-### <code>require-strict</code>
+2. Add `recommended` config to your ESLint setup
 
-_The `--fix` option on the command line automatically fixes problems reported by this rule._
+   ```ts
+   eslintPluginZod.configs.recommended,
+   ```
 
-Requires that objects are initialized with `.strict()`.
+Here’s a minimal example using the flat config format:
 
-<a name="user-content-eslint-plugin-zod-rules-require-strict-options"></a>
-<a name="eslint-plugin-zod-rules-require-strict-options"></a>
-#### Options
+```ts
+// eslint.config.js
+import { defineConfig } from 'eslint/config';
+import eslint from '@eslint/js';
+import eslintPluginZod from 'eslint-plugin-zod';
 
-|configuration|format|default|description|
-|---|---|---|---|
-|`allowPassthrough`|boolean|`true`|Ignores objects explicitly set to `allowPassthrough()`.|
+export default defineConfig(
+  eslint.configs.recommended,
+  eslintPluginZod.configs.recommended,
+);
+```
 
+## Zod peer dependency version
 
+`eslint-plugin-zod` is designed for projects that use `zod@^4`.
+While the plugin analyzes Zod schemas in your code,
+it doesn’t import or depend on Zod at runtime.
+To document this relationship without forcing installation,
+Zod is declared as an optional peer dependency in the plugin’s `package.json`.
 
+If your project uses Zod v4, the plugin will automatically lint your schemas.
+If you’re not using Zod (for example, in a separate ESLint workspace), you don’t need to install it.

package/dist/index.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const meta_js_1 = require("./meta.cjs");
+const array_style_js_1 = require("./rules/array-style.cjs");
+const consistent_import_source_js_1 = require("./rules/consistent-import-source.cjs");
+const consistent_object_schema_type_js_1 = require("./rules/consistent-object-schema-type.cjs");
+const no_any_schema_js_1 = require("./rules/no-any-schema.cjs");
+const no_empty_custom_schema_js_1 = require("./rules/no-empty-custom-schema.cjs");
+const no_number_schema_with_int_js_1 = require("./rules/no-number-schema-with-int.cjs");
+const no_optional_and_default_together_js_1 = require("./rules/no-optional-and-default-together.cjs");
+const no_throw_in_refine_js_1 = require("./rules/no-throw-in-refine.cjs");
+const no_unknown_schema_js_1 = require("./rules/no-unknown-schema.cjs");
+const prefer_enum_over_literal_union_js_1 = require("./rules/prefer-enum-over-literal-union.cjs");
+const prefer_meta_last_js_1 = require("./rules/prefer-meta-last.cjs");
+const prefer_meta_js_1 = require("./rules/prefer-meta.cjs");
+const prefer_namespace_import_js_1 = require("./rules/prefer-namespace-import.cjs");
+const require_brand_type_parameter_js_1 = require("./rules/require-brand-type-parameter.cjs");
+const require_error_message_js_1 = require("./rules/require-error-message.cjs");
+const require_schema_suffix_js_1 = require("./rules/require-schema-suffix.cjs");
+const schema_error_property_style_js_1 = require("./rules/schema-error-property-style.cjs");
+const eslintPluginZod = {
+    meta: {
+        name: meta_js_1.PLUGIN_NAME,
+        version: meta_js_1.PLUGIN_VERSION,
+    },
+    rules: {
+        'array-style': array_style_js_1.arrayStyle,
+        'consistent-import-source': consistent_import_source_js_1.consistentImportSource,
+        'consistent-object-schema-type': consistent_object_schema_type_js_1.consistentObjectSchemaType,
+        'no-any-schema': no_any_schema_js_1.noAnySchema,
+        'no-empty-custom-schema': no_empty_custom_schema_js_1.noEmptyCustomSchema,
+        'no-number-schema-with-int': no_number_schema_with_int_js_1.noNumberSchemaWithInt,
+        'no-optional-and-default-together': no_optional_and_default_together_js_1.noOptionalAndDefaultTogether,
+        'no-throw-in-refine': no_throw_in_refine_js_1.noThrowInRefine,
+        'no-unknown-schema': no_unknown_schema_js_1.noUnknownSchema,
+        'prefer-enum-over-literal-union': prefer_enum_over_literal_union_js_1.preferEnumOverLiteralUnion,
+        'prefer-meta': prefer_meta_js_1.preferMeta,
+        'prefer-meta-last': prefer_meta_last_js_1.preferMetaLast,
+        'prefer-namespace-import': prefer_namespace_import_js_1.preferNamespaceImport,
+        'require-brand-type-parameter': require_brand_type_parameter_js_1.requireBrandTypeParameter,
+        'require-error-message': require_error_message_js_1.requireErrorMessage,
+        'require-schema-suffix': require_schema_suffix_js_1.requireSchemaSuffix,
+        'schema-error-property-style': schema_error_property_style_js_1.schemaErrorPropertyStyle,
+    },
+};
+const recommendedConfig = {
+    name: `${meta_js_1.PLUGIN_NAME}/recommended`,
+    files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
+    plugins: {
+        zod: eslintPluginZod,
+    },
+    rules: {
+        'zod/array-style': 'error',
+        'zod/no-any-schema': 'error',
+        'zod/no-empty-custom-schema': 'error',
+        'zod/no-number-schema-with-int': '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-namespace-import': 'error',
+        'zod/require-brand-type-parameter': 'error',
+        'zod/require-error-message': 'error',
+        'zod/require-schema-suffix': 'error',
+    },
+};
+exports.default = Object.assign(Object.assign({}, eslintPluginZod), { configs: {
+        recommended: recommendedConfig,
+    } });
+module.exports = exports.default;

package/dist/index.d.cts

@@ -0,0 +1,21 @@
+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.ts

@@ -0,0 +1,21 @@
+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 _default;

package/dist/index.js

@@ -0,0 +1,68 @@
+import { PLUGIN_NAME, PLUGIN_VERSION } from "./meta.js";
+import { arrayStyle } from "./rules/array-style.js";
+import { consistentImportSource } from "./rules/consistent-import-source.js";
+import { consistentObjectSchemaType } from "./rules/consistent-object-schema-type.js";
+import { noAnySchema } from "./rules/no-any-schema.js";
+import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.js";
+import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.js";
+import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.js";
+import { noThrowInRefine } from "./rules/no-throw-in-refine.js";
+import { noUnknownSchema } from "./rules/no-unknown-schema.js";
+import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.js";
+import { preferMetaLast } from "./rules/prefer-meta-last.js";
+import { preferMeta } from "./rules/prefer-meta.js";
+import { preferNamespaceImport } from "./rules/prefer-namespace-import.js";
+import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.js";
+import { requireErrorMessage } from "./rules/require-error-message.js";
+import { requireSchemaSuffix } from "./rules/require-schema-suffix.js";
+import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.js";
+const eslintPluginZod = {
+    meta: {
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+    },
+    rules: {
+        'array-style': arrayStyle,
+        'consistent-import-source': consistentImportSource,
+        'consistent-object-schema-type': consistentObjectSchemaType,
+        'no-any-schema': noAnySchema,
+        'no-empty-custom-schema': noEmptyCustomSchema,
+        'no-number-schema-with-int': noNumberSchemaWithInt,
+        'no-optional-and-default-together': noOptionalAndDefaultTogether,
+        'no-throw-in-refine': noThrowInRefine,
+        'no-unknown-schema': noUnknownSchema,
+        'prefer-enum-over-literal-union': preferEnumOverLiteralUnion,
+        'prefer-meta': preferMeta,
+        'prefer-meta-last': preferMetaLast,
+        'prefer-namespace-import': preferNamespaceImport,
+        'require-brand-type-parameter': requireBrandTypeParameter,
+        'require-error-message': requireErrorMessage,
+        'require-schema-suffix': requireSchemaSuffix,
+        '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/no-any-schema': 'error',
+        'zod/no-empty-custom-schema': 'error',
+        'zod/no-number-schema-with-int': '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-namespace-import': 'error',
+        'zod/require-brand-type-parameter': 'error',
+        'zod/require-error-message': 'error',
+        'zod/require-schema-suffix': 'error',
+    },
+};
+export default Object.assign(Object.assign({}, eslintPluginZod), { configs: {
+        recommended: recommendedConfig,
+    } });

package/dist/meta.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_VERSION = exports.PLUGIN_NAME = void 0;
+exports.getRuleURL = getRuleURL;
+const node_fs_1 = require("node:fs");
+const packageJSON = JSON.parse((0, node_fs_1.readFileSync)(new URL('../package.json', require("url").pathToFileURL(__filename)), 'utf8'));
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage, } = packageJSON;
+exports.PLUGIN_NAME = PLUGIN_NAME;
+exports.PLUGIN_VERSION = PLUGIN_VERSION;
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, '');
+function getRuleURL(ruleID) {
+    return `${PLUGIN_HOMEPAGE}/blob/HEAD/docs/rules/${ruleID}.md`;
+}

package/dist/meta.d.cts

@@ -0,0 +1,3 @@
+declare const PLUGIN_NAME: string, PLUGIN_VERSION: string;
+export { PLUGIN_NAME, PLUGIN_VERSION };
+export declare function getRuleURL(ruleID: string): string;

package/dist/meta.d.ts

@@ -0,0 +1,3 @@
+declare const PLUGIN_NAME: string, PLUGIN_VERSION: string;
+export { PLUGIN_NAME, PLUGIN_VERSION };
+export declare function getRuleURL(ruleID: string): string;

package/dist/meta.js

@@ -0,0 +1,8 @@
+import { readFileSync } from 'node:fs';
+const packageJSON = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage, } = packageJSON;
+export { PLUGIN_NAME, PLUGIN_VERSION };
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, '');
+export function getRuleURL(ruleID) {
+    return `${PLUGIN_HOMEPAGE}/blob/HEAD/docs/rules/${ruleID}.md`;
+}

package/dist/rules/array-style.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayStyle = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const is_zod_expression_js_1 = require("../utils/is-zod-expression.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+const ZOD_ARRAY_STYLES = ['function', 'method'];
+const defaultOptions = { style: 'function' };
+exports.arrayStyle = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    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, } = (0, track_zod_schema_imports_js_1.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 chain = collectZodChainMethods(node);
+                                    const arrayCall = chain.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 { callee } = node;
+                if ((0, is_zod_expression_js_1.isZodExpressionEndingWithMethod)(callee, 'array') &&
+                    node.arguments.length === 0) {
+                    if (schemaDecl === 'namespace') {
+                        context.report({
+                            node,
+                            messageId: 'useFunction',
+                            fix(fixer) {
+                                const objText = sourceCode.getText(callee.object);
+                                return fixer.replaceText(node, `z.array(${objText})`);
+                            },
+                        });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'useFunction',
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/array-style.d.cts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const ZOD_ARRAY_STYLES: string[];
+interface Options {
+    style: (typeof ZOD_ARRAY_STYLES)[number];
+}
+type MessageIds = 'useFunction' | 'useMethod';
+export declare const arrayStyle: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/array-style.d.ts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const ZOD_ARRAY_STYLES: string[];
+interface Options {
+    style: (typeof ZOD_ARRAY_STYLES)[number];
+}
+type MessageIds = 'useFunction' | 'useMethod';
+export declare const arrayStyle: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};