eslint-plugin-zod 3.5.1 → 3.5.2

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

@@ -1,41 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noEmptyCustomSchema = 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.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: {
-            noEmptyCustomSchema: 'You should provide a validate function within `z.custom()`',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    return;
-                }
-                if (zodSchemaMeta.schemaType === 'custom' &&
-                    node.arguments.length === 0) {
-                    context.report({
-                        node,
-                        messageId: 'noEmptyCustomSchema',
-                    });
-                }
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/no-empty-custom-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("all");
+const noEmptyCustomSchema = require_create_plugin_rule.createZodPluginRule({
+	name: "no-empty-custom-schema",
+	meta: {
+		hasSuggestions: false,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.custom()` without arguments"
+		},
+		messages: { noEmptyCustomSchema: "You should provide a validate function within `z.custom()`" },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType === "custom" && node.arguments.length === 0) context.report({
+					node,
+					messageId: "noEmptyCustomSchema"
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.noEmptyCustomSchema = noEmptyCustomSchema;

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

@@ -0,0 +1,34 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/no-empty-custom-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const noEmptyCustomSchema = createZodPluginRule({
+	name: "no-empty-custom-schema",
+	meta: {
+		hasSuggestions: false,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.custom()` without arguments"
+		},
+		messages: { noEmptyCustomSchema: "You should provide a validate function within `z.custom()`" },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType === "custom" && node.arguments.length === 0) context.report({
+					node,
+					messageId: "noEmptyCustomSchema"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noEmptyCustomSchema };

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

@@ -1,63 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noNumberSchemaWithInt = void 0;
-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");
-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: {
-            removeNumber: '`z.number().int()` is considered legacy. Use `z.int()` instead.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) !== 'number') {
-                    return;
-                }
-                const methods = collectZodChainMethods(node);
-                const intIndex = methods.findIndex((m) => m.name === 'int');
-                if (intIndex === -1) {
-                    return;
-                }
-                const numberIndex = methods.findIndex((m) => m.name === 'number');
-                if (zodSchemaMeta.schemaDecl === 'named') {
-                    context.report({
-                        node,
-                        messageId: 'removeNumber',
-                    });
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: 'removeNumber',
-                    fix(fixer) {
-                        return (0, build_zod_chain_replacement_fix_js_1.buildZodChainReplacementFix)({
-                            sourceCode,
-                            fixer,
-                            methods,
-                            fromIndex: numberIndex,
-                            toIndex: intIndex,
-                            toMethodName: 'int',
-                        });
-                    },
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+const require_build_zod_chain_replacement_fix = require("../utils/build-zod-chain-replacement-fix.cjs");
+//#region src/rules/no-number-schema-with-int.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noNumberSchemaWithInt = require_create_plugin_rule.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: { removeNumber: "`z.number().int()` is considered legacy. Use `z.int()` 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 !== "number") return;
+				const methods = collectZodChainMethods(node);
+				const intIndex = methods.findIndex((m) => m.name === "int");
+				if (intIndex === -1) return;
+				const numberIndex = methods.findIndex((m) => m.name === "number");
+				if (zodSchemaMeta.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "removeNumber"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "removeNumber",
+					fix(fixer) {
+						return require_build_zod_chain_replacement_fix.buildZodChainReplacementFix({
+							sourceCode,
+							fixer,
+							methods,
+							fromIndex: numberIndex,
+							toIndex: intIndex,
+							toMethodName: "int"
+						});
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.noNumberSchemaWithInt = noNumberSchemaWithInt;

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

@@ -0,0 +1,57 @@
+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-number-schema-with-int.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+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: { removeNumber: "`z.number().int()` is considered legacy. Use `z.int()` 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 !== "number") return;
+				const methods = collectZodChainMethods(node);
+				const intIndex = methods.findIndex((m) => m.name === "int");
+				if (intIndex === -1) return;
+				const numberIndex = methods.findIndex((m) => m.name === "number");
+				if (zodSchemaMeta.schemaDecl === "named") {
+					context.report({
+						node,
+						messageId: "removeNumber"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "removeNumber",
+					fix(fixer) {
+						return buildZodChainReplacementFix({
+							sourceCode,
+							fixer,
+							methods,
+							fromIndex: numberIndex,
+							toIndex: intIndex,
+							toMethodName: "int"
+						});
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNumberSchemaWithInt };

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

@@ -1,81 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noOptionalAndDefaultTogether = 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)('zod');
-const preferredMethods = ['none', 'default', 'optional'];
-const defaultOptions = { preferredMethod: 'none' };
-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: {
-            noOptionalAndDefaultTogether: 'Using both `.optional()` and `.default()` is redundant. A schema with a default value is already optional.',
-            noOptionalAndDefaultTogetherRemoveMethod: 'Using both `.optional()` and `.default()` is redundant. Remove the `.{{method}}()` method to avoid redundancy.',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    preferredMethod: {
-                        description: 'Determines which method to keep when both are present',
-                        type: 'string',
-                        enum: [...preferredMethods],
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [defaultOptions],
-    create(context, [{ preferredMethod }]) {
-        const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                if (!detectZodSchemaRootNode(node)) {
-                    return;
-                }
-                const methods = collectZodChainMethods(node);
-                if (methods.length === 0) {
-                    return;
-                }
-                const optionalMethod = methods.find((m) => m.name === 'optional');
-                const defaultMethod = methods.find((m) => m.name === 'default');
-                if (!optionalMethod || !defaultMethod) {
-                    return;
-                }
-                const reportNode = methods.indexOf(optionalMethod) > methods.indexOf(defaultMethod)
-                    ? optionalMethod.node
-                    : defaultMethod.node;
-                if (preferredMethod === 'none') {
-                    context.report({
-                        node: reportNode,
-                        messageId: 'noOptionalAndDefaultTogether',
-                    });
-                    return;
-                }
-                const methodToRemoveName = preferredMethod === 'default' ? 'optional' : 'default';
-                context.report({
-                    node: reportNode,
-                    messageId: 'noOptionalAndDefaultTogetherRemoveMethod',
-                    data: { method: methodToRemoveName },
-                    fix(fixer) {
-                        const nodeToRemove = preferredMethod === 'default'
-                            ? optionalMethod.node
-                            : defaultMethod.node;
-                        const calleeToRemove = nodeToRemove.callee;
-                        return fixer.replaceText(nodeToRemove, sourceCode.getText(calleeToRemove.object));
-                    },
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/no-optional-and-default-together.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("zod");
+const preferredMethods = [
+	"none",
+	"default",
+	"optional"
+];
+const defaultOptions = { preferredMethod: "none" };
+const noOptionalAndDefaultTogether = require_create_plugin_rule.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: {
+			noOptionalAndDefaultTogether: "Using both `.optional()` and `.default()` is redundant. A schema with a default value is already optional.",
+			noOptionalAndDefaultTogetherRemoveMethod: "Using both `.optional()` and `.default()` is redundant. Remove the `.{{method}}()` method to avoid redundancy."
+		},
+		schema: [{
+			type: "object",
+			properties: { preferredMethod: {
+				description: "Determines which method to keep when both are present",
+				type: "string",
+				enum: [...preferredMethods]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ preferredMethod }]) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const methods = collectZodChainMethods(node);
+				if (methods.length === 0) return;
+				const optionalMethod = methods.find((m) => m.name === "optional");
+				const defaultMethod = methods.find((m) => m.name === "default");
+				if (!optionalMethod || !defaultMethod) return;
+				const reportNode = methods.indexOf(optionalMethod) > methods.indexOf(defaultMethod) ? optionalMethod.node : defaultMethod.node;
+				if (preferredMethod === "none") {
+					context.report({
+						node: reportNode,
+						messageId: "noOptionalAndDefaultTogether"
+					});
+					return;
+				}
+				const methodToRemoveName = preferredMethod === "default" ? "optional" : "default";
+				context.report({
+					node: reportNode,
+					messageId: "noOptionalAndDefaultTogetherRemoveMethod",
+					data: { method: methodToRemoveName },
+					fix(fixer) {
+						const nodeToRemove = preferredMethod === "default" ? optionalMethod.node : defaultMethod.node;
+						const calleeToRemove = nodeToRemove.callee;
+						return fixer.replaceText(nodeToRemove, sourceCode.getText(calleeToRemove.object));
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.noOptionalAndDefaultTogether = noOptionalAndDefaultTogether;

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

@@ -0,0 +1,71 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/no-optional-and-default-together.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const preferredMethods = [
+	"none",
+	"default",
+	"optional"
+];
+const defaultOptions = { preferredMethod: "none" };
+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: {
+			noOptionalAndDefaultTogether: "Using both `.optional()` and `.default()` is redundant. A schema with a default value is already optional.",
+			noOptionalAndDefaultTogetherRemoveMethod: "Using both `.optional()` and `.default()` is redundant. Remove the `.{{method}}()` method to avoid redundancy."
+		},
+		schema: [{
+			type: "object",
+			properties: { preferredMethod: {
+				description: "Determines which method to keep when both are present",
+				type: "string",
+				enum: [...preferredMethods]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ preferredMethod }]) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const methods = collectZodChainMethods(node);
+				if (methods.length === 0) return;
+				const optionalMethod = methods.find((m) => m.name === "optional");
+				const defaultMethod = methods.find((m) => m.name === "default");
+				if (!optionalMethod || !defaultMethod) return;
+				const reportNode = methods.indexOf(optionalMethod) > methods.indexOf(defaultMethod) ? optionalMethod.node : defaultMethod.node;
+				if (preferredMethod === "none") {
+					context.report({
+						node: reportNode,
+						messageId: "noOptionalAndDefaultTogether"
+					});
+					return;
+				}
+				const methodToRemoveName = preferredMethod === "default" ? "optional" : "default";
+				context.report({
+					node: reportNode,
+					messageId: "noOptionalAndDefaultTogetherRemoveMethod",
+					data: { method: methodToRemoveName },
+					fix(fixer) {
+						const nodeToRemove = preferredMethod === "default" ? optionalMethod.node : defaultMethod.node;
+						const calleeToRemove = nodeToRemove.callee;
+						return fixer.replaceText(nodeToRemove, sourceCode.getText(calleeToRemove.object));
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noOptionalAndDefaultTogether };

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

@@ -1,64 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noStringSchemaWithUuid = void 0;
-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");
-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',
-        },
-        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 === null || zodSchemaMeta === void 0 ? void 0 : 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 (0, build_zod_chain_replacement_fix_js_1.buildZodChainReplacementFix)({
-                            sourceCode,
-                            fixer,
-                            methods,
-                            fromIndex: stringIndex,
-                            toIndex: uuidIndex,
-                            toMethodName: 'uuid',
-                        });
-                    },
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+const require_build_zod_chain_replacement_fix = require("../utils/build-zod-chain-replacement-fix.cjs");
+//#region src/rules/no-string-schema-with-uuid.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const noStringSchemaWithUuid = require_create_plugin_rule.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 require_build_zod_chain_replacement_fix.buildZodChainReplacementFix({
+							sourceCode,
+							fixer,
+							methods,
+							fromIndex: stringIndex,
+							toIndex: uuidIndex,
+							toMethodName: "uuid"
+						});
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.noStringSchemaWithUuid = noStringSchemaWithUuid;