eslint-plugin-zod-mini 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,149 @@
+# eslint-plugin-zod-mini
+
+[![CI][CIBadge]][CIURL]
+[![Code style: prettier][CodeStyleBadge]][CodeStyleURL]
+[![Lint: eslint][lintBadge]][lintURL]
+[![npm version][npmVersionBadge]][npmVersionURL]
+[![issues][issuesBadge]][issuesURL]
+
+[CIBadge]: https://img.shields.io/github/actions/workflow/status/marcalexiei/eslint-plugin-zod/ci.yml?style=for-the-badge&logo=github&event=push&label=CI
+[CIURL]: https://github.com/marcalexiei/eslint-plugin-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-mini.svg?style=for-the-badge&logo=npm
+[npmVersionURL]: https://www.npmjs.com/package/eslint-plugin-zod-mini
+[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-plugin-zod.svg?style=for-the-badge
+[issuesURL]: https://github.com/marcalexiei/eslint-plugin-zod/issues
+
+[ESLint](https://eslint.org) plugin that adds custom linting rules to enforce best practices when using [Zod Mini](https://zod.dev/?id=zod-mini) (`zod/mini`).
+
+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).\
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
+❌ Deprecated.
+
+| Name                                                                                     | Description                                                                                        | 💼  | 🔧  | 💡  | ❌  |
+| :--------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod Mini                                                     | ✅  | 🔧  |     |     |
+| [consistent-import-source](docs/rules/consistent-import-source.md)                       | Enforce consistent source from Zod Mini imports                                                    |     |     | 💡  |     |
+| [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)             | Enforce consistent usage of Zod Mini schema methods                                                |     |     | 💡  |     |
+| [consistent-schema-output-type-style](docs/rules/consistent-schema-output-type-style.md) | Enforce consistent use of z.infer or z.output for schema type inference                            |     | 🔧  |     |     |
+| [consistent-schema-var-name](docs/rules/consistent-schema-var-name.md)                   | Enforce a consistent naming convention for Zod Mini schema variables                               | ✅  |     |     |     |
+| [no-any-schema](docs/rules/no-any-schema.md)                                             | Disallow usage of `z.any()` in Zod Mini schemas                                                    | ✅  |     | 💡  |     |
+| [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                           | Disallow usage of `z.custom()` without arguments                                                   | ✅  |     |     |     |
+| [no-unknown-schema](docs/rules/no-unknown-schema.md)                                     | Disallow usage of `z.unknown()` in Zod Mini schemas                                                |     |     |     |     |
+| [prefer-meta](docs/rules/prefer-meta.md)                                                 | Enforce usage of `z.meta()` over `z.describe()`                                                    | ✅  | 🔧  |     |     |
+| [prefer-namespace-import](docs/rules/prefer-namespace-import.md)                         | Enforce importing zod/mini as a namespace import (`import * as z from 'zod/mini'`)                 |     | 🔧  |     | ❌  |
+| [require-brand-type-parameter](docs/rules/require-brand-type-parameter.md)               | Require type parameter on `.brand()` functions                                                     | ✅  |     | 💡  |     |
+| [require-error-message](docs/rules/require-error-message.md)                             | Enforce that custom refinements include an error message                                           | ✅  | 🔧  |     |     |
+| [require-schema-suffix](docs/rules/require-schema-suffix.md)                             | Require schema suffix when declaring a Zod Mini schema                                             |     |     |     | ❌  |
+| [schema-error-property-style](docs/rules/schema-error-property-style.md)                 | Enforce consistent style for error messages in Zod Mini schema validation (using ESQuery patterns) |     |     |     |     |
+
+<!-- end auto-generated rules list -->
+
+## Installation
+
+### ESLint
+
+Install `eslint` and `eslint-plugin-zod-mini` using your preferred package manager:
+
+```shell
+npm i --save-dev eslint eslint-plugin-zod-mini
+```
+
+```shell
+yarn add --dev eslint eslint-plugin-zod-mini
+```
+
+```shell
+pnpm add --save-dev eslint eslint-plugin-zod-mini
+```
+
+#### ESLint Configuration
+
+1. Import the plugin
+
+   ```ts
+   import eslintPluginZodMini from 'eslint-plugin-zod-mini';
+   ```
+
+2. Add `recommended` config to your ESLint setup
+
+   ```ts
+   eslintPluginZodMini.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 eslintPluginZodMini from 'eslint-plugin-zod-mini';
+
+export default defineConfig(
+  eslint.configs.recommended,
+  eslintPluginZodMini.configs.recommended,
+);
+```
+
+### Oxlint
+
+Install `oxlint` and `eslint-plugin-zod-mini` using your preferred package manager:
+
+```shell
+npm i --save-dev oxlint eslint-plugin-zod-mini
+```
+
+```shell
+yarn add --dev oxlint eslint-plugin-zod-mini
+```
+
+```shell
+pnpm add --save-dev oxlint eslint-plugin-zod-mini
+```
+
+#### Oxlint Configuration
+
+1. Import the plugin
+
+   ```ts
+   import eslintPluginZodMini from 'eslint-plugin-zod-mini';
+   ```
+
+2. Add `eslint-plugin-zod-mini` to the `jsPlugins` key
+
+   ```ts
+   {
+     jsPlugins: ['eslint-plugin-zod-mini'],
+     // ...
+   }
+   ```
+
+3. Add `eslintPluginZodMini.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 eslintPluginZodMini from 'eslint-plugin-zod-mini';
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+  jsPlugins: ['eslint-plugin-zod-mini'],
+  rules: {
+    ...eslintPluginZodMini.configs.recommended.rules,
+  },
+});
+```

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -0,0 +1,62 @@
+const require_meta = require("./meta.cjs");
+const require_consistent_import_source = require("./rules/consistent-import-source.cjs");
+const require_consistent_import = require("./rules/consistent-import.cjs");
+const require_consistent_object_schema_type = require("./rules/consistent-object-schema-type.cjs");
+const require_consistent_schema_output_type_style = require("./rules/consistent-schema-output-type-style.cjs");
+const require_consistent_schema_var_name = require("./rules/consistent-schema-var-name.cjs");
+const require_no_any_schema = require("./rules/no-any-schema.cjs");
+const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
+const require_prefer_meta = require("./rules/prefer-meta.cjs");
+const require_prefer_namespace_import = require("./rules/prefer-namespace-import.cjs");
+const require_require_brand_type_parameter = require("./rules/require-brand-type-parameter.cjs");
+const require_require_error_message = require("./rules/require-error-message.cjs");
+const require_require_schema_suffix = require("./rules/require-schema-suffix.cjs");
+const require_schema_error_property_style = require("./rules/schema-error-property-style.cjs");
+//#region src/index.ts
+const eslintPluginZodMini = {
+	meta: {
+		name: require_meta.PLUGIN_NAME,
+		version: require_meta.PLUGIN_VERSION
+	},
+	rules: {
+		"consistent-import": require_consistent_import.consistentImport,
+		"consistent-import-source": require_consistent_import_source.consistentImportSource,
+		"consistent-object-schema-type": require_consistent_object_schema_type.consistentObjectSchemaType,
+		"consistent-schema-output-type-style": require_consistent_schema_output_type_style.consistentSchemaOutputTypeStyle,
+		"consistent-schema-var-name": require_consistent_schema_var_name.consistentSchemaVarName,
+		"no-any-schema": require_no_any_schema.noAnySchema,
+		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
+		"prefer-meta": require_prefer_meta.preferMeta,
+		"prefer-namespace-import": require_prefer_namespace_import.preferNamespaceImport,
+		"require-brand-type-parameter": require_require_brand_type_parameter.requireBrandTypeParameter,
+		"require-error-message": require_require_error_message.requireErrorMessage,
+		"require-schema-suffix": require_require_schema_suffix.requireSchemaSuffix,
+		"schema-error-property-style": require_schema_error_property_style.schemaErrorPropertyStyle
+	}
+};
+const recommendedConfig = {
+	name: `${require_meta.PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { "zod-mini": eslintPluginZodMini },
+	rules: {
+		"zod-mini/consistent-import": "error",
+		"zod-mini/consistent-schema-var-name": "error",
+		"zod-mini/no-any-schema": "error",
+		"zod-mini/no-empty-custom-schema": "error",
+		"zod-mini/prefer-meta": "error",
+		"zod-mini/require-brand-type-parameter": "error",
+		"zod-mini/require-error-message": "error"
+	}
+};
+var src_default = {
+	...eslintPluginZodMini,
+	configs: { recommended: recommendedConfig }
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-plugin-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,62 @@
+import { PLUGIN_NAME, PLUGIN_VERSION } from "./meta.mjs";
+import { consistentImportSource } from "./rules/consistent-import-source.mjs";
+import { consistentImport } from "./rules/consistent-import.mjs";
+import { consistentObjectSchemaType } from "./rules/consistent-object-schema-type.mjs";
+import { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-output-type-style.mjs";
+import { consistentSchemaVarName } from "./rules/consistent-schema-var-name.mjs";
+import { noAnySchema } from "./rules/no-any-schema.mjs";
+import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
+import { preferMeta } from "./rules/prefer-meta.mjs";
+import { preferNamespaceImport } from "./rules/prefer-namespace-import.mjs";
+import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.mjs";
+import { requireErrorMessage } from "./rules/require-error-message.mjs";
+import { requireSchemaSuffix } from "./rules/require-schema-suffix.mjs";
+import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.mjs";
+//#region src/index.ts
+const eslintPluginZodMini = {
+	meta: {
+		name: PLUGIN_NAME,
+		version: PLUGIN_VERSION
+	},
+	rules: {
+		"consistent-import": consistentImport,
+		"consistent-import-source": consistentImportSource,
+		"consistent-object-schema-type": consistentObjectSchemaType,
+		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle,
+		"consistent-schema-var-name": consistentSchemaVarName,
+		"no-any-schema": noAnySchema,
+		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-unknown-schema": noUnknownSchema,
+		"prefer-meta": preferMeta,
+		"prefer-namespace-import": preferNamespaceImport,
+		"require-brand-type-parameter": requireBrandTypeParameter,
+		"require-error-message": requireErrorMessage,
+		"require-schema-suffix": requireSchemaSuffix,
+		"schema-error-property-style": schemaErrorPropertyStyle
+	}
+};
+const recommendedConfig = {
+	name: `${PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { "zod-mini": eslintPluginZodMini },
+	rules: {
+		"zod-mini/consistent-import": "error",
+		"zod-mini/consistent-schema-var-name": "error",
+		"zod-mini/no-any-schema": "error",
+		"zod-mini/no-empty-custom-schema": "error",
+		"zod-mini/prefer-meta": "error",
+		"zod-mini/require-brand-type-parameter": "error",
+		"zod-mini/require-error-message": "error"
+	}
+};
+var src_default = {
+	...eslintPluginZodMini,
+	configs: { recommended: recommendedConfig }
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-plugin-zod/issues/49
+*/
+//#endregion
+export { src_default as default };

package/dist/meta.cjs

@@ -0,0 +1,12 @@
+require("./_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, "");
+function getRuleURL(ruleID) {
+	return `${PLUGIN_HOMEPAGE}/blob/v${PLUGIN_VERSION}/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,9 @@
+import { readFileSync } from "node:fs";
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, "");
+function getRuleURL(ruleID) {
+	return `${PLUGIN_HOMEPAGE}/blob/v${PLUGIN_VERSION}/docs/rules/${ruleID}.md`;
+}
+//#endregion
+export { PLUGIN_NAME, PLUGIN_VERSION, getRuleURL };

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

@@ -0,0 +1,61 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/consistent-import-source.ts
+const consistentImportSource = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "consistent-import-source",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource: "zod-mini",
+			description: "Enforce consistent source from Zod Mini imports"
+		},
+		messages: {
+			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
+			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
+		},
+		schema: [{
+			type: "object",
+			properties: { sources: {
+				type: "array",
+				description: "An array of allowed Zod import sources.",
+				items: {
+					type: "string",
+					enum: [..._eslint_zod_utils.ZOD_IMPORT_SOURCES]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ sources: ["zod/mini"] }],
+	create(context, [{ sources }]) {
+		return { ImportDeclaration(node) {
+			const sourceValue = node.source.value;
+			if (!sourceValue.startsWith("zod")) return;
+			if (sources.includes(sourceValue)) return;
+			context.report({
+				node,
+				messageId: "sourceNotAllowed",
+				data: {
+					source: sourceValue,
+					sources: sources.map((s) => `"${s}"`).join(", ")
+				},
+				suggest: sources.map((it) => ({
+					messageId: "replaceSource",
+					data: {
+						valid: it,
+						invalid: sourceValue
+					},
+					fix(fixer) {
+						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
+					}
+				}))
+			});
+		} };
+	}
+});
+//#endregion
+exports.consistentImportSource = consistentImportSource;

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

@@ -0,0 +1,60 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { ZOD_IMPORT_SOURCES } from "@eslint-zod/utils";
+//#region src/rules/consistent-import-source.ts
+const consistentImportSource = createZodMiniPluginRule({
+	name: "consistent-import-source",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource: "zod-mini",
+			description: "Enforce consistent source from Zod Mini imports"
+		},
+		messages: {
+			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
+			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
+		},
+		schema: [{
+			type: "object",
+			properties: { sources: {
+				type: "array",
+				description: "An array of allowed Zod import sources.",
+				items: {
+					type: "string",
+					enum: [...ZOD_IMPORT_SOURCES]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ sources: ["zod/mini"] }],
+	create(context, [{ sources }]) {
+		return { ImportDeclaration(node) {
+			const sourceValue = node.source.value;
+			if (!sourceValue.startsWith("zod")) return;
+			if (sources.includes(sourceValue)) return;
+			context.report({
+				node,
+				messageId: "sourceNotAllowed",
+				data: {
+					source: sourceValue,
+					sources: sources.map((s) => `"${s}"`).join(", ")
+				},
+				suggest: sources.map((it) => ({
+					messageId: "replaceSource",
+					data: {
+						valid: it,
+						invalid: sourceValue
+					},
+					fix(fixer) {
+						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
+					}
+				}))
+			});
+		} };
+	}
+});
+//#endregion
+export { consistentImportSource };

package/dist/rules/consistent-import.cjs

@@ -0,0 +1,153 @@
+require("../_virtual/_rolldown/runtime.cjs");
+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-import.ts
+const IMPORT_SYNTAXES = ["namespace", "named"];
+/**
+* Determines whether the first import in a group is valid for a given import
+* syntax (`named` or `namespace`), taking into account whether the group
+* contains only type imports.
+*
+* Rules enforced:
+* - For `named` syntax:
+*   - The first import must have exactly one specifier
+*   - That specifier must be a named import of identifier `z`
+* - For `namespace` syntax:
+*   - The first import must have exactly one namespace specifier
+* - If the group contains only type imports, the first import must explicitly
+*   be declared as `import type`
+*
+* @param group - Metadata describing the import group
+* @param syntax - Expected import syntax for the group
+* @returns `true` if the first import matches the expected syntax and type rules
+*/
+function isGroupFirstImportKindValidForSyntax(group, syntax) {
+	const { hasOnlyTypeImports, nodes } = group;
+	const [firstImportNode] = nodes;
+	const { specifiers, importKind } = firstImportNode;
+	if (specifiers.length !== 1) return false;
+	const [specifier] = specifiers;
+	if (!(syntax === "named" ? specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && specifier.imported.name === "z" : specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier)) return false;
+	if (hasOnlyTypeImports) return importKind === "type";
+	return true;
+}
+function shouldIdentifierBeRenamed(node) {
+	if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) return false;
+	if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && node.parent.object.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.parent.object.name !== node.name) return false;
+	return true;
+}
+/**
+* From a given specifiers retrieve the most significant to use when creating an alias import
+*/
+function getNamespaceAliasNameFrom(node) {
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier) return node.local.name;
+	if (node.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.imported.name === "z") return node.local.name;
+	return null;
+}
+const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "consistent-import",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource: "zod-mini",
+			description: "Enforce a consistent import style for Zod Mini"
+		},
+		fixable: "code",
+		messages: {
+			changeImportSyntax: "Use a {{syntax}} import for Zod Mini.",
+			removeDuplicate: "Remove duplicate Zod Mini import; Zod Mini is already imported.",
+			convertUsage: "Update Zod Mini usage to match the {{syntax}} import syntax."
+		},
+		schema: [{
+			type: "object",
+			properties: { syntax: {
+				description: "Specifies the import syntax to use for Zod Mini.",
+				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 (!(0, _eslint_zod_utils.isZodImportSource)(source.value, "zod-mini")) return;
+				if (!importGroups[source.value]) 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;
+					/**
+					* Variable to track all specifiers that later are used by {@link getDeclaredVariables}
+					* to add the namespace prefix
+					*/
+					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
+exports.consistentImport = consistentImport;