eslint-plugin-zod 3.5.1 → 3.5.2

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

@@ -0,0 +1,58 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { buildZodChainReplacementFix } from "../utils/build-zod-chain-replacement-fix.mjs";
+//#region src/rules/no-string-schema-with-uuid.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+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"
+		},
+		messages: { useUuid: "`z.string().uuid()` is redundant. Use `z.uuid()` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "string") return;
+				const methods = collectZodChainMethods(node);
+				const uuidIndex = methods.findIndex((m) => m.name === "uuid");
+				if (uuidIndex === -1) return;
+				const stringIndex = methods.findIndex((m) => m.name === "string");
+				if (zodSchemaMeta.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "useUuid"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useUuid",
+					fix(fixer) {
+						return buildZodChainReplacementFix({
+							sourceCode,
+							fixer,
+							methods,
+							fromIndex: stringIndex,
+							toIndex: uuidIndex,
+							toMethodName: "uuid"
+						});
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noStringSchemaWithUuid };

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

@@ -1,88 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noThrowInRefine = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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');
-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: {
-            noThrowInRefine: 'Do not throw errors directly inside a z.refine callback.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        function checkNode(node) {
-            if (!node) {
-                return;
-            }
-            switch (node.type) {
-                case utils_1.AST_NODE_TYPES.ThrowStatement:
-                    context.report({ node, messageId: 'noThrowInRefine' });
-                    break;
-                case utils_1.AST_NODE_TYPES.BlockStatement:
-                    node.body.forEach(checkNode);
-                    break;
-                case utils_1.AST_NODE_TYPES.IfStatement:
-                    checkNode(node.consequent);
-                    if (node.alternate) {
-                        checkNode(node.alternate);
-                    }
-                    break;
-                case utils_1.AST_NODE_TYPES.ForStatement:
-                case utils_1.AST_NODE_TYPES.ForInStatement:
-                case utils_1.AST_NODE_TYPES.ForOfStatement:
-                case utils_1.AST_NODE_TYPES.WhileStatement:
-                case utils_1.AST_NODE_TYPES.DoWhileStatement:
-                    checkNode(node.body);
-                    break;
-                case utils_1.AST_NODE_TYPES.TryStatement:
-                    checkNode(node.block);
-                    if (node.handler) {
-                        checkNode(node.handler.body);
-                    }
-                    if (node.finalizer) {
-                        checkNode(node.finalizer);
-                    }
-                    break;
-                case utils_1.AST_NODE_TYPES.FunctionExpression:
-                case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
-                case utils_1.AST_NODE_TYPES.FunctionDeclaration:
-                    return;
-                default:
-                    if ('body' in node && Array.isArray(node.body)) {
-                        node.body.forEach(checkNode);
-                    }
-                    break;
-            }
-        }
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    return;
-                }
-                const methods = collectZodChainMethods(node);
-                const refineMethod = methods.find((it) => it.name === 'refine');
-                if (!refineMethod) {
-                    return;
-                }
-                const [callback] = refineMethod.node.arguments;
-                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                    checkNode(callback.body);
-                }
-            },
-        };
-    },
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/no-throw-in-refine.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noThrowInRefine = require_create_plugin_rule.createZodPluginRule({
+	name: "no-throw-in-refine",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow throwing errors directly inside Zod refine callbacks"
+		},
+		messages: { noThrowInRefine: "Do not throw errors directly inside a z.refine callback." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		function checkNode(node) {
+			if (!node) return;
+			switch (node.type) {
+				case _typescript_eslint_utils.AST_NODE_TYPES.ThrowStatement:
+					context.report({
+						node,
+						messageId: "noThrowInRefine"
+					});
+					break;
+				case _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement:
+					node.body.forEach(checkNode);
+					break;
+				case _typescript_eslint_utils.AST_NODE_TYPES.IfStatement:
+					checkNode(node.consequent);
+					if (node.alternate) checkNode(node.alternate);
+					break;
+				case _typescript_eslint_utils.AST_NODE_TYPES.ForStatement:
+				case _typescript_eslint_utils.AST_NODE_TYPES.ForInStatement:
+				case _typescript_eslint_utils.AST_NODE_TYPES.ForOfStatement:
+				case _typescript_eslint_utils.AST_NODE_TYPES.WhileStatement:
+				case _typescript_eslint_utils.AST_NODE_TYPES.DoWhileStatement:
+					checkNode(node.body);
+					break;
+				case _typescript_eslint_utils.AST_NODE_TYPES.TryStatement:
+					checkNode(node.block);
+					if (node.handler) checkNode(node.handler.body);
+					if (node.finalizer) checkNode(node.finalizer);
+					break;
+				case _typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression:
+				case _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression:
+				case _typescript_eslint_utils.AST_NODE_TYPES.FunctionDeclaration: return;
+				default:
+					if ("body" in node && Array.isArray(node.body)) node.body.forEach(checkNode);
+					break;
+			}
+		}
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const refineMethod = collectZodChainMethods(node).find((it) => it.name === "refine");
+				if (!refineMethod) return;
+				const [callback] = refineMethod.node.arguments;
+				if (callback.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === _typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression) checkNode(callback.body);
+			}
+		};
+	}
 });
+//#endregion
+exports.noThrowInRefine = noThrowInRefine;

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

@@ -0,0 +1,69 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/no-throw-in-refine.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const noThrowInRefine = createZodPluginRule({
+	name: "no-throw-in-refine",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow throwing errors directly inside Zod refine callbacks"
+		},
+		messages: { noThrowInRefine: "Do not throw errors directly inside a z.refine callback." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		function checkNode(node) {
+			if (!node) return;
+			switch (node.type) {
+				case AST_NODE_TYPES.ThrowStatement:
+					context.report({
+						node,
+						messageId: "noThrowInRefine"
+					});
+					break;
+				case AST_NODE_TYPES.BlockStatement:
+					node.body.forEach(checkNode);
+					break;
+				case AST_NODE_TYPES.IfStatement:
+					checkNode(node.consequent);
+					if (node.alternate) checkNode(node.alternate);
+					break;
+				case AST_NODE_TYPES.ForStatement:
+				case AST_NODE_TYPES.ForInStatement:
+				case AST_NODE_TYPES.ForOfStatement:
+				case AST_NODE_TYPES.WhileStatement:
+				case AST_NODE_TYPES.DoWhileStatement:
+					checkNode(node.body);
+					break;
+				case AST_NODE_TYPES.TryStatement:
+					checkNode(node.block);
+					if (node.handler) checkNode(node.handler.body);
+					if (node.finalizer) checkNode(node.finalizer);
+					break;
+				case AST_NODE_TYPES.FunctionExpression:
+				case AST_NODE_TYPES.ArrowFunctionExpression:
+				case AST_NODE_TYPES.FunctionDeclaration: return;
+				default:
+					if ("body" in node && Array.isArray(node.body)) node.body.forEach(checkNode);
+					break;
+			}
+		}
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const refineMethod = collectZodChainMethods(node).find((it) => it.name === "refine");
+				if (!refineMethod) return;
+				const [callback] = refineMethod.node.arguments;
+				if (callback.type === AST_NODE_TYPES.ArrowFunctionExpression || callback.type === AST_NODE_TYPES.FunctionExpression) checkNode(callback.body);
+			}
+		};
+	}
+});
+//#endregion
+export { noThrowInRefine };

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

@@ -1,36 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noUnknownSchema = void 0;
-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)('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: {
-            noZUnknown: 'Using `z.unknown()` is not allowed. Please use a more specific schema.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) === 'unknown') {
-                    context.report({
-                        node,
-                        messageId: 'noZUnknown',
-                    });
-                }
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/no-unknown-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("all");
+const noUnknownSchema = require_create_plugin_rule.createZodPluginRule({
+	name: "no-unknown-schema",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.unknown()` in Zod schemas"
+		},
+		messages: { noZUnknown: "Using `z.unknown()` is not allowed. Please use a more specific schema." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType === "unknown") context.report({
+					node,
+					messageId: "noZUnknown"
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.noUnknownSchema = noUnknownSchema;

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

@@ -0,0 +1,31 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/no-unknown-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const noUnknownSchema = createZodPluginRule({
+	name: "no-unknown-schema",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.unknown()` in Zod schemas"
+		},
+		messages: { noZUnknown: "Using `z.unknown()` is not allowed. Please use a more specific schema." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType === "unknown") context.report({
+					node,
+					messageId: "noZUnknown"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noUnknownSchema };

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

@@ -1,80 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferEnumOverLiteralUnion = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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');
-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: {
-            useEnum: 'Replace this union of string literals with `z.enum()`.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchema = detectZodSchemaRootNode(node);
-                if ((zodSchema === null || zodSchema === void 0 ? void 0 : zodSchema.schemaType) !== 'union') {
-                    return;
-                }
-                const methods = collectZodChainMethods(zodSchema.node);
-                const union = methods.find((it) => it.name === 'union');
-                if (!union) {
-                    return;
-                }
-                const unionNode = union.node;
-                const unionArgument = unionNode.arguments.at(0);
-                if ((unionArgument === null || unionArgument === void 0 ? void 0 : unionArgument.type) !== utils_1.AST_NODE_TYPES.ArrayExpression) {
-                    return;
-                }
-                const zodLiteralStrings = unionArgument.elements.map((s) => {
-                    if (!s) {
-                        return null;
-                    }
-                    const maybeLiteralSchema = detectZodSchemaRootNode(s);
-                    if ((maybeLiteralSchema === null || maybeLiteralSchema === void 0 ? void 0 : maybeLiteralSchema.schemaType) !== 'literal') {
-                        return null;
-                    }
-                    const [literalArgument] = maybeLiteralSchema.node.arguments;
-                    if (literalArgument.type === utils_1.AST_NODE_TYPES.Literal &&
-                        typeof literalArgument.value === 'string') {
-                        return literalArgument.raw;
-                    }
-                    return null;
-                });
-                if (zodLiteralStrings.some((it) => it === null)) {
-                    return;
-                }
-                if (zodSchema.schemaDecl === 'named') {
-                    context.report({
-                        node,
-                        messageId: 'useEnum',
-                    });
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: 'useEnum',
-                    fix(fixer) {
-                        return [
-                            fixer.replaceText(unionNode.callee.property, 'enum'),
-                            fixer.replaceText(unionNode.arguments[0], `[${zodLiteralStrings.join(', ')}]`),
-                        ];
-                    },
-                });
-            },
-        };
-    },
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/prefer-enum-over-literal-union.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const preferEnumOverLiteralUnion = require_create_plugin_rule.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: { useEnum: "Replace this union of string literals with `z.enum()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchema = detectZodSchemaRootNode(node);
+				if (zodSchema?.schemaType !== "union") return;
+				const union = collectZodChainMethods(zodSchema.node).find((it) => it.name === "union");
+				if (!union) return;
+				const unionNode = union.node;
+				const unionArgument = unionNode.arguments.at(0);
+				if (unionArgument?.type !== _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) return;
+				/**
+				* Collect zod literals name that later can be used to implement the fix,
+				* if the item isn't a literal schema return null
+				*/
+				const zodLiteralStrings = unionArgument.elements.map((s) => {
+					if (!s) return null;
+					const maybeLiteralSchema = detectZodSchemaRootNode(s);
+					if (maybeLiteralSchema?.schemaType !== "literal") return null;
+					const [literalArgument] = maybeLiteralSchema.node.arguments;
+					if (literalArgument.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof literalArgument.value === "string") return literalArgument.raw;
+					return null;
+				});
+				if (zodLiteralStrings.some((it) => it === null)) return;
+				if (zodSchema.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "useEnum"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useEnum",
+					fix(fixer) {
+						return [fixer.replaceText(unionNode.callee.property, "enum"), fixer.replaceText(unionNode.arguments[0], `[${zodLiteralStrings.join(", ")}]`)];
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.preferEnumOverLiteralUnion = preferEnumOverLiteralUnion;

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

@@ -0,0 +1,63 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/prefer-enum-over-literal-union.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+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: { useEnum: "Replace this union of string literals with `z.enum()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchema = detectZodSchemaRootNode(node);
+				if (zodSchema?.schemaType !== "union") return;
+				const union = collectZodChainMethods(zodSchema.node).find((it) => it.name === "union");
+				if (!union) return;
+				const unionNode = union.node;
+				const unionArgument = unionNode.arguments.at(0);
+				if (unionArgument?.type !== AST_NODE_TYPES.ArrayExpression) return;
+				/**
+				* Collect zod literals name that later can be used to implement the fix,
+				* if the item isn't a literal schema return null
+				*/
+				const zodLiteralStrings = unionArgument.elements.map((s) => {
+					if (!s) return null;
+					const maybeLiteralSchema = detectZodSchemaRootNode(s);
+					if (maybeLiteralSchema?.schemaType !== "literal") return null;
+					const [literalArgument] = maybeLiteralSchema.node.arguments;
+					if (literalArgument.type === AST_NODE_TYPES.Literal && typeof literalArgument.value === "string") return literalArgument.raw;
+					return null;
+				});
+				if (zodLiteralStrings.some((it) => it === null)) return;
+				if (zodSchema.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "useEnum"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useEnum",
+					fix(fixer) {
+						return [fixer.replaceText(unionNode.callee.property, "enum"), fixer.replaceText(unionNode.arguments[0], `[${zodLiteralStrings.join(", ")}]`)];
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferEnumOverLiteralUnion };