eslint-plugin-zod-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Marco Pasqualetti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,135 @@
+# eslint-plugin-zod-core
+
+[![CI Status][CIBadge]][CIURL]
+[![Code style: prettier][CodeStyleBadge]][CodeStyleURL]
+[![Lint: eslint][lintBadge]][lintURL]
+[![Open on npmx][npmVersionBadge]][npmVersionURL]
+[![Open issue tracker][issuesBadge]][issuesURL]
+
+[CIBadge]: https://img.shields.io/github/actions/workflow/status/marcalexiei/eslint-zod/ci.yml?style=for-the-badge&logo=github&event=push&label=CI
+[CIURL]: https://github.com/marcalexiei/eslint-zod/actions/workflows/CI.yml/badge.svg
+[CodeStyleBadge]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=for-the-badge&logo=prettier
+[CodeStyleURL]: https://prettier.io
+[npmVersionBadge]: https://img.shields.io/npm/v/eslint-plugin-zod-core.svg?style=for-the-badge&logo=npm
+[npmVersionURL]: https://npmx.dev/package/eslint-plugin-zod-core
+[lintBadge]: https://img.shields.io/badge/lint-eslint-3A33D1?logo=eslint&style=for-the-badge
+[lintURL]: https://eslint.org
+[issuesBadge]: https://img.shields.io/github/issues/marcalexiei/eslint-zod.svg?style=for-the-badge
+[issuesURL]: https://github.com/marcalexiei/eslint-zod/issues
+
+[ESLint](https://eslint.org) plugin that adds custom linting rules to enforce best practices when using [Zod Core](https://zod.dev) (`zod/v4/core`).
+
+It can also work with [Oxlint](https://oxc.rs/docs/guide/usage/linter.html)!\
+Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linter/js-plugins.html).
+
+## Rules
+
+<!-- begin auto-generated rules list -->
+
+💼 Configurations enabled in.\
+✅ Set in the `recommended` configuration.\
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
+
+| Name                                                                                     | Description                                                                   | 💼  | 🔧  |
+| :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------- | :-- | :-- |
+| [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod core                                | ✅  | 🔧  |
+| [consistent-schema-output-type-style](docs/rules/consistent-schema-output-type-style.md) | Enforce consistent use of core.infer or core.output for schema type inference |     | 🔧  |
+
+<!-- end auto-generated rules list -->
+
+## Installation
+
+### ESLint
+
+Install `eslint` and `eslint-plugin-zod-core` using your preferred package manager:
+
+```shell
+npm i --save-dev eslint eslint-plugin-zod-core
+```
+
+```shell
+yarn add --dev eslint eslint-plugin-zod-core
+```
+
+```shell
+pnpm add --save-dev eslint eslint-plugin-zod-core
+```
+
+#### ESLint Configuration
+
+1. Import the plugin
+
+   ```ts
+   import eslintPluginZodCore from 'eslint-plugin-zod-core';
+   ```
+
+2. Add `recommended` config to your ESLint setup
+
+   ```ts
+   eslintPluginZodCore.configs.recommended,
+   ```
+
+Here's a minimal example using the flat config format:
+
+```ts
+// eslint.config.js
+import { defineConfig } from 'eslint/config';
+import eslint from '@eslint/js';
+import eslintPluginZodCore from 'eslint-plugin-zod-core';
+
+export default defineConfig(
+  eslint.configs.recommended,
+  eslintPluginZodCore.configs.recommended,
+);
+```
+
+### Oxlint
+
+Install `oxlint` and `eslint-plugin-zod-core` using your preferred package manager:
+
+```shell
+npm i --save-dev oxlint eslint-plugin-zod-core
+```
+
+```shell
+yarn add --dev oxlint eslint-plugin-zod-core
+```
+
+```shell
+pnpm add --save-dev oxlint eslint-plugin-zod-core
+```
+
+#### Oxlint Configuration
+
+1. Import the plugin
+
+   ```ts
+   import eslintPluginZodCore from 'eslint-plugin-zod-core';
+   ```
+
+2. Add `eslint-plugin-zod-core` to the `jsPlugins` key
+
+   ```ts
+   {
+     jsPlugins: ['eslint-plugin-zod-core'],
+     // ...
+   }
+   ```
+
+3. Add `eslintPluginZodCore.configs.recommended.rules` to your Oxlint config.\
+   Alternatively you can specify the rules manually
+
+Here's a minimal example using the flat config format:
+
+```ts
+// oxlint.config.ts
+import eslintPluginZodCore from 'eslint-plugin-zod-core';
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+  jsPlugins: ['eslint-plugin-zod-core'],
+  rules: {
+    ...eslintPluginZodCore.configs.recommended.rules,
+  },
+});
+```

package/dist/index.cjs

@@ -0,0 +1,30 @@
+const require_meta = require("./meta.cjs");
+const require_consistent_import = require("./rules/consistent-import.cjs");
+const require_consistent_schema_output_type_style = require("./rules/consistent-schema-output-type-style.cjs");
+//#region src/index.ts
+const eslintPluginZodCore = {
+	meta: {
+		name: require_meta.PLUGIN_NAME,
+		version: require_meta.PLUGIN_VERSION
+	},
+	rules: {
+		"consistent-import": require_consistent_import.consistentImport,
+		"consistent-schema-output-type-style": require_consistent_schema_output_type_style.consistentSchemaOutputTypeStyle
+	}
+};
+const recommendedConfig = {
+	name: `${require_meta.PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { "zod-core": eslintPluginZodCore },
+	rules: { "zod-core/consistent-import": "error" }
+};
+var src_default = {
+	...eslintPluginZodCore,
+	configs: { recommended: recommendedConfig }
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-zod/issues/49
+*/
+//#endregion
+module.exports = src_default;

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+//#region src/index.d.ts
+interface CompatibleConfig {
+  name?: string;
+  rules?: object;
+  plugins?: Record<string, CompatiblePlugin>;
+}
+interface CompatiblePlugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+}
+declare const _default: {
+  configs: {
+    recommended: CompatibleConfig;
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+};
+export = _default;

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+//#region src/index.d.ts
+interface CompatibleConfig {
+  name?: string;
+  rules?: object;
+  plugins?: Record<string, CompatiblePlugin>;
+}
+interface CompatiblePlugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+}
+declare const _default: {
+  configs: {
+    recommended: CompatibleConfig;
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+};
+//#endregion
+export { _default as default };

package/dist/index.mjs

@@ -0,0 +1,30 @@
+import { PLUGIN_NAME, PLUGIN_VERSION } from "./meta.mjs";
+import { consistentImport } from "./rules/consistent-import.mjs";
+import { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-output-type-style.mjs";
+//#region src/index.ts
+const eslintPluginZodCore = {
+	meta: {
+		name: PLUGIN_NAME,
+		version: PLUGIN_VERSION
+	},
+	rules: {
+		"consistent-import": consistentImport,
+		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle
+	}
+};
+const recommendedConfig = {
+	name: `${PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { "zod-core": eslintPluginZodCore },
+	rules: { "zod-core/consistent-import": "error" }
+};
+var src_default = {
+	...eslintPluginZodCore,
+	configs: { recommended: recommendedConfig }
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-zod/issues/49
+*/
+//#endregion
+export { src_default as default };

package/dist/meta.cjs

@@ -0,0 +1,10 @@
+let node_fs = require("node:fs");
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, repository } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+function getRuleURL(ruleID) {
+	return `${repository.url}/blob/HEAD/${repository.directory}/docs/rules/${ruleID}.md`;
+}
+//#endregion
+exports.PLUGIN_NAME = PLUGIN_NAME;
+exports.PLUGIN_VERSION = PLUGIN_VERSION;
+exports.getRuleURL = getRuleURL;

package/dist/meta.mjs

@@ -0,0 +1,8 @@
+import { readFileSync } from "node:fs";
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, repository } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+function getRuleURL(ruleID) {
+	return `${repository.url}/blob/HEAD/${repository.directory}/docs/rules/${ruleID}.md`;
+}
+//#endregion
+export { PLUGIN_NAME, PLUGIN_VERSION, getRuleURL };

package/dist/rules/consistent-import.cjs

@@ -0,0 +1,102 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/consistent-import.ts
+const consistentImport = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-import",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce a consistent import style for Zod core" },
+		fixable: "code",
+		messages: {
+			changeImportSyntax: "Use a {{syntax}} import for Zod core.",
+			removeDuplicate: "Remove duplicate Zod core import; Zod core is already imported.",
+			convertUsage: "Update Zod core usage to match the {{syntax}} import syntax."
+		},
+		schema: [{
+			type: "object",
+			properties: { syntax: {
+				description: "Specifies the import syntax to use for Zod core.",
+				type: "string",
+				enum: _eslint_zod_utils.IMPORT_SYNTAXES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ syntax: "namespace" }],
+	create(context, [options]) {
+		const { syntax } = options;
+		const { sourceCode } = context;
+		const importGroups = {};
+		return {
+			ImportDeclaration(node) {
+				const { source, importKind } = node;
+				if (!_eslint_zod_utils.zodCoreImportScope.isAllowed(source.value)) return;
+				importGroups[source.value] ??= {
+					hasOnlyTypeImports: true,
+					nodes: []
+				};
+				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
+				importGroups[source.value].nodes.push(node);
+			},
+			"Program:exit": function() {
+				let namespaceAliasNameIndex = 0;
+				for (const importGroup of Object.values(importGroups)) {
+					const { hasOnlyTypeImports, nodes } = importGroup;
+					const [firstImportNode, ...othersImportNodes] = nodes;
+					const nodesWithVariablesToUpdate = [];
+					let namespaceAliasName = null;
+					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+						if (!namespaceAliasName) {
+							namespaceAliasName = (0, _eslint_zod_utils.getNamespaceAliasNameFrom)(specifier);
+							if (namespaceAliasName) continue;
+						}
+						nodesWithVariablesToUpdate.push(specifier);
+					}
+					if (!namespaceAliasName) {
+						namespaceAliasName = "z";
+						if (namespaceAliasNameIndex > 0) {
+							namespaceAliasName = `z${namespaceAliasNameIndex}`;
+							namespaceAliasNameIndex += 1;
+						}
+					}
+					if (!(0, _eslint_zod_utils.isGroupFirstImportKindValidForSyntax)(importGroup, syntax)) context.report({
+						node: firstImportNode,
+						messageId: "changeImportSyntax",
+						data: { syntax },
+						fix(fixer) {
+							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
+							let importSpecifier;
+							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
+							else importSpecifier = `{ z as ${namespaceAliasName} }`;
+							else importSpecifier = `* as ${namespaceAliasName}`;
+							const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
+							return fixer.replaceText(firstImportNode, newImportText);
+						}
+					});
+					const allReferences = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it)).flatMap((it) => it.references);
+					for (const ref of allReferences) {
+						const { identifier } = ref;
+						if ((0, _eslint_zod_utils.shouldIdentifierBeRenamed)(identifier)) context.report({
+							node: identifier,
+							messageId: "convertUsage",
+							data: { syntax },
+							fix(fixer) {
+								const newId = `${namespaceAliasName}.${identifier.name}`;
+								return fixer.replaceText(identifier, newId);
+							}
+						});
+					}
+					for (const extraImport of othersImportNodes) context.report({
+						node: extraImport,
+						messageId: "removeDuplicate",
+						fix(fixer) {
+							return fixer.removeRange(extraImport.range);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentImport = consistentImport;

package/dist/rules/consistent-import.mjs

@@ -0,0 +1,102 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { IMPORT_SYNTAXES, getNamespaceAliasNameFrom, isGroupFirstImportKindValidForSyntax, shouldIdentifierBeRenamed, zodCoreImportScope } from "@eslint-zod/utils";
+//#region src/rules/consistent-import.ts
+const consistentImport = createZodPluginRule({
+	name: "consistent-import",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce a consistent import style for Zod core" },
+		fixable: "code",
+		messages: {
+			changeImportSyntax: "Use a {{syntax}} import for Zod core.",
+			removeDuplicate: "Remove duplicate Zod core import; Zod core is already imported.",
+			convertUsage: "Update Zod core usage to match the {{syntax}} import syntax."
+		},
+		schema: [{
+			type: "object",
+			properties: { syntax: {
+				description: "Specifies the import syntax to use for Zod core.",
+				type: "string",
+				enum: IMPORT_SYNTAXES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ syntax: "namespace" }],
+	create(context, [options]) {
+		const { syntax } = options;
+		const { sourceCode } = context;
+		const importGroups = {};
+		return {
+			ImportDeclaration(node) {
+				const { source, importKind } = node;
+				if (!zodCoreImportScope.isAllowed(source.value)) return;
+				importGroups[source.value] ??= {
+					hasOnlyTypeImports: true,
+					nodes: []
+				};
+				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
+				importGroups[source.value].nodes.push(node);
+			},
+			"Program:exit": function() {
+				let namespaceAliasNameIndex = 0;
+				for (const importGroup of Object.values(importGroups)) {
+					const { hasOnlyTypeImports, nodes } = importGroup;
+					const [firstImportNode, ...othersImportNodes] = nodes;
+					const nodesWithVariablesToUpdate = [];
+					let namespaceAliasName = null;
+					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+						if (!namespaceAliasName) {
+							namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+							if (namespaceAliasName) continue;
+						}
+						nodesWithVariablesToUpdate.push(specifier);
+					}
+					if (!namespaceAliasName) {
+						namespaceAliasName = "z";
+						if (namespaceAliasNameIndex > 0) {
+							namespaceAliasName = `z${namespaceAliasNameIndex}`;
+							namespaceAliasNameIndex += 1;
+						}
+					}
+					if (!isGroupFirstImportKindValidForSyntax(importGroup, syntax)) context.report({
+						node: firstImportNode,
+						messageId: "changeImportSyntax",
+						data: { syntax },
+						fix(fixer) {
+							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
+							let importSpecifier;
+							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
+							else importSpecifier = `{ z as ${namespaceAliasName} }`;
+							else importSpecifier = `* as ${namespaceAliasName}`;
+							const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
+							return fixer.replaceText(firstImportNode, newImportText);
+						}
+					});
+					const allReferences = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it)).flatMap((it) => it.references);
+					for (const ref of allReferences) {
+						const { identifier } = ref;
+						if (shouldIdentifierBeRenamed(identifier)) context.report({
+							node: identifier,
+							messageId: "convertUsage",
+							data: { syntax },
+							fix(fixer) {
+								const newId = `${namespaceAliasName}.${identifier.name}`;
+								return fixer.replaceText(identifier, newId);
+							}
+						});
+					}
+					for (const extraImport of othersImportNodes) context.report({
+						node: extraImport,
+						messageId: "removeDuplicate",
+						fix(fixer) {
+							return fixer.removeRange(extraImport.range);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { consistentImport };

package/dist/rules/consistent-schema-output-type-style.cjs

@@ -0,0 +1,66 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/consistent-schema-output-type-style.ts
+const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodCoreImportScope);
+const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-schema-output-type-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Enforce consistent use of core.infer or core.output for schema type inference" },
+		messages: {
+			useInfer: "Use infer instead of output.",
+			useOutput: "Use output instead of infer."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style to use for schema type inference",
+				type: "string",
+				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ style: "output" }],
+	create(context, [{ style }]) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			TSTypeReference(node) {
+				const { typeName } = node;
+				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.TSQualifiedName) {
+					const { left, right } = typeName;
+					if (left.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
+					const usedStyle = right.name;
+					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
+					context.report({
+						node: right,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							return fixer.replaceText(right, style);
+						}
+					});
+					return;
+				}
+				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					const originalName = getNamedImportOriginal(typeName.name);
+					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
+					const targetLocalName = getNamedImportLocal(style);
+					context.report({
+						node: typeName,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							if (!targetLocalName || targetLocalName === "infer") return null;
+							return fixer.replaceText(typeName, targetLocalName);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentSchemaOutputTypeStyle = consistentSchemaOutputTypeStyle;

package/dist/rules/consistent-schema-output-type-style.mjs

@@ -0,0 +1,66 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack, zodCoreImportScope } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-schema-output-type-style.ts
+const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodCoreImportScope);
+const consistentSchemaOutputTypeStyle = createZodPluginRule({
+	name: "consistent-schema-output-type-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Enforce consistent use of core.infer or core.output for schema type inference" },
+		messages: {
+			useInfer: "Use infer instead of output.",
+			useOutput: "Use output instead of infer."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style to use for schema type inference",
+				type: "string",
+				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ style: "output" }],
+	create(context, [{ style }]) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			TSTypeReference(node) {
+				const { typeName } = node;
+				if (typeName.type === AST_NODE_TYPES.TSQualifiedName) {
+					const { left, right } = typeName;
+					if (left.type !== AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
+					const usedStyle = right.name;
+					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
+					context.report({
+						node: right,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							return fixer.replaceText(right, style);
+						}
+					});
+					return;
+				}
+				if (typeName.type === AST_NODE_TYPES.Identifier) {
+					const originalName = getNamedImportOriginal(typeName.name);
+					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
+					const targetLocalName = getNamedImportLocal(style);
+					context.report({
+						node: typeName,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							if (!targetLocalName || targetLocalName === "infer") return null;
+							return fixer.replaceText(typeName, targetLocalName);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { consistentSchemaOutputTypeStyle };

package/dist/utils/create-plugin-rule.cjs

@@ -0,0 +1,5 @@
+const require_meta = require("../meta.cjs");
+//#region src/utils/create-plugin-rule.ts
+const createZodPluginRule = require("@typescript-eslint/utils").ESLintUtils.RuleCreator(require_meta.getRuleURL);
+//#endregion
+exports.createZodPluginRule = createZodPluginRule;

package/dist/utils/create-plugin-rule.mjs

@@ -0,0 +1,6 @@
+import { getRuleURL } from "../meta.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+//#region src/utils/create-plugin-rule.ts
+const createZodPluginRule = ESLintUtils.RuleCreator(getRuleURL);
+//#endregion
+export { createZodPluginRule };

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "eslint-plugin-zod-core",
+  "version": "0.1.0",
+  "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod core",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "oxlint",
+    "zod"
+  ],
+  "homepage": "https://github.com/marcalexiei/eslint-zod#readme",
+  "bugs": {
+    "url": "https://github.com/marcalexiei/eslint-zod/issues"
+  },
+  "license": "MIT",
+  "author": "Marco Pasqualetti @marcalexiei",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marcalexiei/eslint-zod",
+    "directory": "plugins/eslint-plugin-zod-core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.57.0",
+    "@eslint-zod/utils": "1.0.1"
+  },
+  "devDependencies": {
+    "@marcalexiei/prettier-config": "1.1.4",
+    "@typescript-eslint/rule-tester": "8.59.2",
+    "dedent": "1.7.2",
+    "eslint-doc-generator": "3.3.2",
+    "prettier": "3.8.3",
+    "tsdown": "0.21.10",
+    "vitest": "4.1.5"
+  },
+  "peerDependencies": {
+    "eslint": "^9 || ^10",
+    "oxlint": "^1.59.0",
+    "zod": "^4"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    },
+    "oxlint": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^20 || ^22 || >=24"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "build:docs": "pnpm run build && eslint-doc-generator",
+    "lint:docs": "eslint-doc-generator --check",
+    "test": "vitest"
+  }
+}