eslint-plugin-zod 3.2.0 → 3.4.0

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) {

package/dist/rules/no-empty-custom-schema.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noEmptyCustomSchema: ESLintUtils.RuleModule<"noEmptyCustomSchema", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noEmptyCustomSchema: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noEmptyCustomSchema", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/no-empty-custom-schema.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noEmptyCustomSchema: ESLintUtils.RuleModule<"noEmptyCustomSchema", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noEmptyCustomSchema: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noEmptyCustomSchema", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

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

@@ -1,12 +1,13 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const noEmptyCustomSchema = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const noEmptyCustomSchema = createZodPluginRule({
     name: 'no-empty-custom-schema',
     meta: {
         hasSuggestions: false,
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.custom()` without arguments',
         },
         messages: {

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

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noNumberSchemaWithInt = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
 const build_zod_chain_replacement_fix_js_1 = require("../utils/build-zod-chain-replacement-fix.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.noNumberSchemaWithInt = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.noNumberSchemaWithInt = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-number-schema-with-int',
     meta: {
         fixable: 'code',
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.number().int()` as it is considered legacy',
         },
         messages: {
@@ -21,7 +22,7 @@ exports.noNumberSchemaWithInt = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRul
     defaultOptions: [],
     create(context) {
         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/no-number-schema-with-int.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noNumberSchemaWithInt: ESLintUtils.RuleModule<"removeNumber", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noNumberSchemaWithInt: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"removeNumber", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/no-number-schema-with-int.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noNumberSchemaWithInt: ESLintUtils.RuleModule<"removeNumber", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noNumberSchemaWithInt: import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeNumber", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-number-schema-with-int.js

@@ -1,13 +1,14 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
 import { buildZodChainReplacementFix } from "../utils/build-zod-chain-replacement-fix.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const noNumberSchemaWithInt = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod');
+export const noNumberSchemaWithInt = createZodPluginRule({
     name: 'no-number-schema-with-int',
     meta: {
         fixable: 'code',
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.number().int()` as it is considered legacy',
         },
         messages: {

package/dist/rules/no-optional-and-default-together.cjs

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noOptionalAndDefaultTogether = 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 { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
 const preferredMethods = ['none', 'default', 'optional'];
 const defaultOptions = { preferredMethod: 'none' };
-exports.noOptionalAndDefaultTogether = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+exports.noOptionalAndDefaultTogether = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-optional-and-default-together',
     meta: {
         type: 'problem',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow using both `.optional()` and `.default()` on the same Zod schema',
         },
         messages: {
@@ -35,11 +36,11 @@ exports.noOptionalAndDefaultTogether = utils_1.ESLintUtils.RuleCreator(meta_js_1
     defaultOptions: [defaultOptions],
     create(context, [{ preferredMethod }]) {
         const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode: isZodSchema, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {
-                if (!isZodSchema(node)) {
+                if (!detectZodSchemaRootNode(node)) {
                     return;
                 }
                 const methods = collectZodChainMethods(node);

package/dist/rules/no-optional-and-default-together.d.cts

@@ -1,11 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 declare const preferredMethods: readonly ["none", "default", "optional"];
 type PreferredMethod = (typeof preferredMethods)[number];
 interface Options {
     preferredMethod: PreferredMethod;
 }
 type MessageIds = 'noOptionalAndDefaultTogether' | 'noOptionalAndDefaultTogetherRemoveMethod';
-export declare const noOptionalAndDefaultTogether: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+export declare const noOptionalAndDefaultTogether: 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/no-optional-and-default-together.d.ts

@@ -1,11 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 declare const preferredMethods: readonly ["none", "default", "optional"];
 type PreferredMethod = (typeof preferredMethods)[number];
 interface Options {
     preferredMethod: PreferredMethod;
 }
 type MessageIds = 'noOptionalAndDefaultTogether' | 'noOptionalAndDefaultTogetherRemoveMethod';
-export declare const noOptionalAndDefaultTogether: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+export declare const noOptionalAndDefaultTogether: 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/no-optional-and-default-together.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 { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod');
 const preferredMethods = ['none', 'default', 'optional'];
 const defaultOptions = { preferredMethod: 'none' };
-export const noOptionalAndDefaultTogether = ESLintUtils.RuleCreator(getRuleURL)({
+export const noOptionalAndDefaultTogether = createZodPluginRule({
     name: 'no-optional-and-default-together',
     meta: {
         type: 'problem',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow using both `.optional()` and `.default()` on the same Zod schema',
         },
         messages: {
@@ -32,11 +33,11 @@ export const noOptionalAndDefaultTogether = ESLintUtils.RuleCreator(getRuleURL)(
     defaultOptions: [defaultOptions],
     create(context, [{ preferredMethod }]) {
         const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode: isZodSchema, collectZodChainMethods, } = trackZodSchemaImports();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {
-                if (!isZodSchema(node)) {
+                if (!detectZodSchemaRootNode(node)) {
                     return;
                 }
                 const methods = collectZodChainMethods(node);

package/dist/rules/no-string-schema-with-uuid.cjs

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noStringSchemaWithUuid = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
 const build_zod_chain_replacement_fix_js_1 = require("../utils/build-zod-chain-replacement-fix.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.noStringSchemaWithUuid = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.noStringSchemaWithUuid = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-string-schema-with-uuid',
     meta: {
         fixable: 'code',
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema',
             url: 'https://zod.dev/api#uuids',
         },
@@ -22,7 +23,7 @@ exports.noStringSchemaWithUuid = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRu
     defaultOptions: [],
     create(context) {
         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/no-string-schema-with-uuid.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noStringSchemaWithUuid: ESLintUtils.RuleModule<"useUuid", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noStringSchemaWithUuid: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"useUuid", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/no-string-schema-with-uuid.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noStringSchemaWithUuid: ESLintUtils.RuleModule<"useUuid", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noStringSchemaWithUuid: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useUuid", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-string-schema-with-uuid.js

@@ -1,13 +1,14 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
 import { buildZodChainReplacementFix } from "../utils/build-zod-chain-replacement-fix.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const noStringSchemaWithUuid = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod');
+export const noStringSchemaWithUuid = createZodPluginRule({
     name: 'no-string-schema-with-uuid',
     meta: {
         fixable: 'code',
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema',
             url: 'https://zod.dev/api#uuids',
         },

package/dist/rules/no-throw-in-refine.cjs

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noThrowInRefine = 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.noThrowInRefine = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.noThrowInRefine = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-throw-in-refine',
     meta: {
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow throwing errors directly inside Zod refine callbacks',
         },
         messages: {
@@ -18,7 +20,7 @@ exports.noThrowInRefine = 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();
         function checkNode(node) {
             if (!node) {
                 return;

package/dist/rules/no-throw-in-refine.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noThrowInRefine: ESLintUtils.RuleModule<"noThrowInRefine", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noThrowInRefine: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noThrowInRefine", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/no-throw-in-refine.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noThrowInRefine: ESLintUtils.RuleModule<"noThrowInRefine", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noThrowInRefine: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noThrowInRefine", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-throw-in-refine.js

@@ -1,11 +1,13 @@
-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 noThrowInRefine = 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('zod');
+export const noThrowInRefine = createZodPluginRule({
     name: 'no-throw-in-refine',
     meta: {
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow throwing errors directly inside Zod refine callbacks',
         },
         messages: {

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

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnknownSchema = 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.noUnknownSchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.noUnknownSchema = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'no-unknown-schema',
     meta: {
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Disallow usage of `z.unknown()` in Zod schemas',
         },
         messages: {
@@ -18,7 +19,7 @@ exports.noUnknownSchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)(
     },
     defaultOptions: [],
     create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {

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

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noUnknownSchema: ESLintUtils.RuleModule<"noZUnknown", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noUnknownSchema: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noZUnknown", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

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

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const noUnknownSchema: ESLintUtils.RuleModule<"noZUnknown", [], unknown, ESLintUtils.RuleListener> & {
+export declare const noUnknownSchema: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noZUnknown", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

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

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

package/dist/rules/prefer-enum-over-literal-union.cjs

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferEnumOverLiteralUnion = 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.preferEnumOverLiteralUnion = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.preferEnumOverLiteralUnion = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'prefer-enum-over-literal-union',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Prefer `z.enum()` over `z.union()` when all members are string literals.',
         },
         messages: {
@@ -19,7 +21,7 @@ exports.preferEnumOverLiteralUnion = utils_1.ESLintUtils.RuleCreator(meta_js_1.g
     },
     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/prefer-enum-over-literal-union.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferEnumOverLiteralUnion: ESLintUtils.RuleModule<"useEnum", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferEnumOverLiteralUnion: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"useEnum", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-enum-over-literal-union.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferEnumOverLiteralUnion: ESLintUtils.RuleModule<"useEnum", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferEnumOverLiteralUnion: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useEnum", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-enum-over-literal-union.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 preferEnumOverLiteralUnion = 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('zod');
+export const preferEnumOverLiteralUnion = createZodPluginRule({
     name: 'prefer-enum-over-literal-union',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Prefer `z.enum()` over `z.union()` when all members are string literals.',
         },
         messages: {

package/dist/rules/prefer-meta-last.cjs

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferMetaLast = 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.preferMetaLast = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.preferMetaLast = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'prefer-meta-last',
     meta: {
         type: 'suggestion',
-        docs: { description: 'Enforce `.meta()` as last method' },
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce `.meta()` as last method',
+        },
         fixable: 'code',
         messages: {
             metaNotLast: 'The `.meta()` methods should be the last one called',
@@ -17,7 +20,7 @@ exports.preferMetaLast = 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/prefer-meta-last.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferMetaLast: ESLintUtils.RuleModule<"metaNotLast", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferMetaLast: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"metaNotLast", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-meta-last.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferMetaLast: ESLintUtils.RuleModule<"metaNotLast", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferMetaLast: import("@typescript-eslint/utils/ts-eslint").RuleModule<"metaNotLast", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-meta-last.js

@@ -1,11 +1,14 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const preferMetaLast = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod');
+export const preferMetaLast = createZodPluginRule({
     name: 'prefer-meta-last',
     meta: {
         type: 'suggestion',
-        docs: { description: 'Enforce `.meta()` as last method' },
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce `.meta()` as last method',
+        },
         fixable: 'code',
         messages: {
             metaNotLast: 'The `.meta()` methods should be the last one called',

package/dist/rules/prefer-meta.cjs

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferMeta = 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.preferMeta = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.preferMeta = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'prefer-meta',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce usage of `.meta()` over `.describe()`',
         },
         messages: {
@@ -19,7 +20,7 @@ exports.preferMeta = 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) {