eslint-plugin-zod 3.3.0 → 3.4.0

package/README.md

@@ -21,36 +21,47 @@
 
 ## Rules
 
+`zod` and `zod-mini` have distinct API surfaces.
+This plugin is primarily built for `zod`, so some rules are exclusive to `zod` and not available for `zod-mini`.
+
 <!-- begin auto-generated rules list -->
 
 💼 Configurations enabled in.\
 ✅ Set in the `recommended` configuration.\
+✔️ Set in the `recommendedMini` 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).\
 ❌ 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                                                |     |     | 💡  |     |
-| [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-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-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'`)                      |     | 🔧  |     | ❌  |
-| [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)     | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                 | ✅  | 🔧  |     |     |
-| [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) |     |     |     |     |
+### Universal rules (`zod` & `zod-mini`)
+
+| Name                                                                         | Description                                                                                   | 💼    | 🔧  | 💡  | ❌  |
+| :--------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | :---- | :-- | :-- | :-- |
+| [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                                                |       |     | 💡  |     |
+| [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-unknown-schema](docs/rules/no-unknown-schema.md)                         | Disallow usage of `z.unknown()` in Zod schemas                                                |       |     |     |     |
+| [prefer-meta](docs/rules/prefer-meta.md)                                     | Enforce usage of `.meta()` over `.describe()`                                                 | ✅ ✔️ | 🔧  |     |     |
+| [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) |       |     |     |     |
+
+### `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                     | ✅  |     |     |     |
+| [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

@@ -49,13 +49,14 @@ const eslintPluginZod = {
         'schema-error-property-style': schema_error_property_style_js_1.schemaErrorPropertyStyle,
     },
 };
-const recommendedConfig = {
+const baseConfig = {
     name: `${meta_js_1.PLUGIN_NAME}/recommended`,
     files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
     plugins: {
         zod: eslintPluginZod,
     },
-    rules: {
+};
+const recommendedConfig = Object.assign(Object.assign({}, baseConfig), { rules: {
         'zod/array-style': 'error',
         'zod/consistent-import': 'error',
         'zod/no-any-schema': 'error',
@@ -71,9 +72,16 @@ const recommendedConfig = {
         'zod/require-brand-type-parameter': 'error',
         'zod/require-error-message': 'error',
         'zod/require-schema-suffix': 'error',
-    },
-};
+    } });
+const recommendedConfigMini = Object.assign(Object.assign({}, baseConfig), { rules: {
+        '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',
+    } });
 exports.default = Object.assign(Object.assign({}, eslintPluginZod), { configs: {
         recommended: recommendedConfig,
+        recommendedMini: recommendedConfigMini,
     } });
 module.exports = exports.default;

package/dist/index.d.cts

@@ -12,6 +12,7 @@ interface CompatiblePlugin {
 declare const _default: {
     configs: {
         recommended: CompatibleConfig;
+        recommendedMini: CompatibleConfig;
     };
     meta: {
         name: string;

package/dist/index.d.ts

@@ -12,6 +12,7 @@ interface CompatiblePlugin {
 declare const _default: {
     configs: {
         recommended: CompatibleConfig;
+        recommendedMini: CompatibleConfig;
     };
     meta: {
         name: string;

package/dist/index.js

@@ -47,13 +47,14 @@ const eslintPluginZod = {
         'schema-error-property-style': schemaErrorPropertyStyle,
     },
 };
-const recommendedConfig = {
+const baseConfig = {
     name: `${PLUGIN_NAME}/recommended`,
     files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
     plugins: {
         zod: eslintPluginZod,
     },
-    rules: {
+};
+const recommendedConfig = Object.assign(Object.assign({}, baseConfig), { rules: {
         'zod/array-style': 'error',
         'zod/consistent-import': 'error',
         'zod/no-any-schema': 'error',
@@ -69,8 +70,15 @@ const recommendedConfig = {
         'zod/require-brand-type-parameter': 'error',
         'zod/require-error-message': 'error',
         'zod/require-schema-suffix': 'error',
-    },
-};
+    } });
+const recommendedConfigMini = Object.assign(Object.assign({}, baseConfig), { rules: {
+        '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',
+    } });
 export default Object.assign(Object.assign({}, eslintPluginZod), { configs: {
         recommended: recommendedConfig,
+        recommendedMini: recommendedConfigMini,
     } });

package/dist/rules/array-style.cjs

@@ -1,17 +1,18 @@
 "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 create_plugin_rule_js_1 = require("../utils/create-plugin-rule.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)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.arrayStyle = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'array-style',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce consistent Zod array style',
         },
         messages: {
@@ -35,7 +36,7 @@ exports.arrayStyle = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
     defaultOptions: [defaultOptions],
     create(context, [{ style }]) {
         const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {

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

@@ -1,10 +1,11 @@
-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> & {
+export declare const arrayStyle: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };
 export {};

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

@@ -1,10 +1,11 @@
-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> & {
+export declare const arrayStyle: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/array-style.js

@@ -1,14 +1,15 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
 const ZOD_ARRAY_STYLES = ['function', 'method'];
 const defaultOptions = { style: 'function' };
-export const arrayStyle = ESLintUtils.RuleCreator(getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod');
+export const arrayStyle = createZodPluginRule({
     name: 'array-style',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce consistent Zod array style',
         },
         messages: {

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

@@ -1,21 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.consistentImportSource = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
-const ZOD_IMPORT_SOURCES = [
-    'zod',
-    'zod/mini',
-    'zod/v4',
-    'zod/v4-mini',
-    'zod/v3',
-];
-exports.consistentImportSource = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
+const is_zod_import_source_js_1 = require("../utils/is-zod-import-source.cjs");
+exports.consistentImportSource = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'consistent-import-source',
     meta: {
         hasSuggestions: true,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource: 'all',
             description: 'Enforce consistent source from Zod imports',
         },
         messages: {
@@ -31,7 +25,7 @@ exports.consistentImportSource = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRu
                         description: 'An array of allowed Zod import sources.',
                         items: {
                             type: 'string',
-                            enum: [...ZOD_IMPORT_SOURCES],
+                            enum: [...is_zod_import_source_js_1.ZOD_IMPORT_SOURCES],
                         },
                         minItems: 1,
                         uniqueItems: true,

package/dist/rules/consistent-import-source.d.cts

@@ -1,10 +1,11 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-declare const ZOD_IMPORT_SOURCES: readonly ["zod", "zod/mini", "zod/v4", "zod/v4-mini", "zod/v3"];
-type ZodImportSource = (typeof ZOD_IMPORT_SOURCES)[number];
+import type { ZodImportSource } from "../utils/is-zod-import-source.cjs";
 type MessageIds = 'sourceNotAllowed' | 'replaceSource';
 export declare const consistentImportSource: TSESLint.RuleModule<MessageIds, [{
     sources: Array<ZodImportSource>;
-}], unknown, TSESLint.RuleListener> & {
+}], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/consistent-import-source.d.ts

@@ -1,10 +1,11 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-declare const ZOD_IMPORT_SOURCES: readonly ["zod", "zod/mini", "zod/v4", "zod/v4-mini", "zod/v3"];
-type ZodImportSource = (typeof ZOD_IMPORT_SOURCES)[number];
+import type { ZodImportSource } from "../utils/is-zod-import-source.js";
 type MessageIds = 'sourceNotAllowed' | 'replaceSource';
 export declare const consistentImportSource: TSESLint.RuleModule<MessageIds, [{
     sources: Array<ZodImportSource>;
-}], unknown, TSESLint.RuleListener> & {
+}], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };
 export {};

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

@@ -1,18 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-const ZOD_IMPORT_SOURCES = [
-    'zod',
-    'zod/mini',
-    'zod/v4',
-    'zod/v4-mini',
-    'zod/v3',
-];
-export const consistentImportSource = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { ZOD_IMPORT_SOURCES } from "../utils/is-zod-import-source.js";
+export const consistentImportSource = createZodPluginRule({
     name: 'consistent-import-source',
     meta: {
         hasSuggestions: true,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource: 'all',
             description: 'Enforce consistent source from Zod imports',
         },
         messages: {

package/dist/rules/consistent-import.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.consistentImport = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const is_zod_import_source_js_1 = require("../utils/is-zod-import-source.cjs");
 const IMPORT_SYNTAXES = ['namespace', 'named'];
 function isGroupFirstImportKindValidForSyntax(group, syntax) {
@@ -48,11 +48,12 @@ function getNamespaceAliasNameFrom(node) {
     }
     return null;
 }
-exports.consistentImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+exports.consistentImport = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'consistent-import',
     meta: {
         type: 'problem',
         docs: {
+            zodImportAllowedSource: 'all',
             description: 'Enforce a consistent import style for Zod',
         },
         fixable: 'code',
@@ -83,7 +84,7 @@ exports.consistentImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)
         return {
             ImportDeclaration(node) {
                 const { source, importKind } = node;
-                if (!(0, is_zod_import_source_js_1.isZodImportSource)(source.value)) {
+                if (!(0, is_zod_import_source_js_1.isZodImportSource)(source.value, 'all')) {
                     return;
                 }
                 if (!importGroups[source.value]) {

package/dist/rules/consistent-import.d.cts

@@ -1,11 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 declare const IMPORT_SYNTAXES: readonly ["namespace", "named"];
 type ImportSyntax = (typeof IMPORT_SYNTAXES)[number];
 interface Options {
     syntax: ImportSyntax;
 }
 type MessageIds = 'changeImportSyntax' | 'removeDuplicate' | 'convertUsage';
-export declare const consistentImport: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+export declare const consistentImport: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/consistent-import.d.ts

@@ -1,11 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 declare const IMPORT_SYNTAXES: readonly ["namespace", "named"];
 type ImportSyntax = (typeof IMPORT_SYNTAXES)[number];
 interface Options {
     syntax: ImportSyntax;
 }
 type MessageIds = 'changeImportSyntax' | 'removeDuplicate' | 'convertUsage';
-export declare const consistentImport: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+export declare const consistentImport: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/consistent-import.js

@@ -1,5 +1,5 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
 import { isZodImportSource } from "../utils/is-zod-import-source.js";
 const IMPORT_SYNTAXES = ['namespace', 'named'];
 function isGroupFirstImportKindValidForSyntax(group, syntax) {
@@ -45,11 +45,12 @@ function getNamespaceAliasNameFrom(node) {
     }
     return null;
 }
-export const consistentImport = ESLintUtils.RuleCreator(getRuleURL)({
+export const consistentImport = createZodPluginRule({
     name: 'consistent-import',
     meta: {
         type: 'problem',
         docs: {
+            zodImportAllowedSource: 'all',
             description: 'Enforce a consistent import style for Zod',
         },
         fixable: 'code',
@@ -80,7 +81,7 @@ export const consistentImport = ESLintUtils.RuleCreator(getRuleURL)({
         return {
             ImportDeclaration(node) {
                 const { source, importKind } = node;
-                if (!isZodImportSource(source.value)) {
+                if (!isZodImportSource(source.value, 'all')) {
                     return;
                 }
                 if (!importGroups[source.value]) {

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

@@ -2,16 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.consistentObjectSchemaType = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
 const ZOD_OBJECT_METHODS = ['object', 'looseObject', 'strictObject'];
 const defaultOptions = { allow: ['object'] };
-exports.consistentObjectSchemaType = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.consistentObjectSchemaType = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'consistent-object-schema-type',
     meta: {
         hasSuggestions: true,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce consistent usage of Zod schema methods',
         },
         messages: {
@@ -39,7 +41,7 @@ exports.consistentObjectSchemaType = utils_1.ESLintUtils.RuleCreator(meta_js_1.g
     },
     defaultOptions: [defaultOptions],
     create(context, [{ allow: allowedList }]) {
-        const { importDeclarationListener, detectZodSchemaRootNode, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {

package/dist/rules/consistent-object-schema-type.d.cts

@@ -5,7 +5,9 @@ interface Options {
     allow: Array<ZodObjectMethod>;
 }
 type MessageIds = 'consistentMethod' | 'useMethod';
-export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], unknown, TSESLint.RuleListener> & {
+export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/consistent-object-schema-type.d.ts

@@ -5,7 +5,9 @@ interface Options {
     allow: Array<ZodObjectMethod>;
 }
 type MessageIds = 'consistentMethod' | 'useMethod';
-export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], unknown, TSESLint.RuleListener> & {
+export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };
 export {};

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

@@ -1,14 +1,16 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
 const ZOD_OBJECT_METHODS = ['object', 'looseObject', 'strictObject'];
 const defaultOptions = { allow: ['object'] };
-export const consistentObjectSchemaType = ESLintUtils.RuleCreator(getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const consistentObjectSchemaType = createZodPluginRule({
     name: 'consistent-object-schema-type',
     meta: {
         hasSuggestions: true,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce consistent usage of Zod schema methods',
         },
         messages: {

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

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noAnySchema = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-exports.noAnySchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.noAnySchema = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-any-schema',
     meta: {
         hasSuggestions: true,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.any()` in Zod schemas',
         },
         messages: {
@@ -20,7 +22,7 @@ exports.noAnySchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
     },
     defaultOptions: [],
     create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {

package/dist/rules/no-any-schema.d.cts

@@ -1,4 +1,6 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export declare const noAnySchema: TSESLint.RuleModule<"noZAny" | "useUnknown", [], unknown, TSESLint.RuleListener> & {
+export declare const noAnySchema: TSESLint.RuleModule<"noZAny" | "useUnknown", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };

package/dist/rules/no-any-schema.d.ts

@@ -1,4 +1,6 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export declare const noAnySchema: TSESLint.RuleModule<"noZAny" | "useUnknown", [], unknown, TSESLint.RuleListener> & {
+export declare const noAnySchema: TSESLint.RuleModule<"noZAny" | "useUnknown", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };

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

@@ -1,12 +1,14 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const noAnySchema = ESLintUtils.RuleCreator(getRuleURL)({
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const noAnySchema = createZodPluginRule({
     name: 'no-any-schema',
     meta: {
         hasSuggestions: true,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.any()` in Zod schemas',
         },
         messages: {

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

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noEmptyCustomSchema = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-exports.noEmptyCustomSchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.noEmptyCustomSchema = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-empty-custom-schema',
     meta: {
         hasSuggestions: false,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.custom()` without arguments',
         },
         messages: {
@@ -19,7 +20,7 @@ exports.noEmptyCustomSchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleU
     },
     defaultOptions: [],
     create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {