eslint-plugin-zod 1.3.0 → 3.0.0

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noNumberSchemaWithInt: ESLintUtils.RuleModule<"removeNumber", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noNumberSchemaWithInt: ESLintUtils.RuleModule<"removeNumber", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,75 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { getOutermostCall } from "../utils/get-outermost-call.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const noNumberSchemaWithInt = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'no-number-schema-with-int',
+    meta: {
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            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) {
+                var _a;
+                const outer = (_a = getOutermostCall(node)) !== null && _a !== void 0 ? _a : node;
+                const zodSchemaMeta = detectZodSchemaRootNode(outer);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaType !== 'number') {
+                    return;
+                }
+                const methods = collectZodChainMethods(outer);
+                const numberIndex = methods.findIndex((m) => m.name === 'number');
+                const intIndex = methods.findIndex((m) => m.name === 'int');
+                if (numberIndex === -1 || intIndex === -1) {
+                    return;
+                }
+                const numberMethod = methods[numberIndex];
+                const intMethod = methods[intIndex];
+                if (node !== intMethod.node) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'removeNumber',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'removeNumber',
+                    fix(fixer) {
+                        const numberNode = numberMethod.node;
+                        const intNode = intMethod.node;
+                        const numberCallee = numberNode.callee;
+                        const prefixObj = numberCallee.object;
+                        const prefixText = sourceCode.getText(prefixObj);
+                        const methodsBetween = methods.slice(numberIndex + 1, intIndex);
+                        const betweenSuffixes = methodsBetween.map((m) => {
+                            const callee = m.node.callee;
+                            const objText = sourceCode.getText(callee.object);
+                            const fullText = sourceCode.getText(m.node);
+                            return fullText.slice(objText.length);
+                        });
+                        const replacement = `${prefixText}.int()${betweenSuffixes.join('')}`;
+                        return fixer.replaceTextRange([numberNode.range[0], intNode.range[1]], replacement);
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOptionalAndDefaultTogether = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+const preferredMethods = ['none', 'default', 'optional'];
+const defaultOptions = { preferredMethod: 'none' };
+exports.noOptionalAndDefaultTogether = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'no-optional-and-default-together',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            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: isZodSchema, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                if (!isZodSchema(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));
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,11 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const preferredMethods: readonly ["none", "default", "optional"];
+type PreferredMethod = (typeof preferredMethods)[number];
+interface Options {
+    preferredMethod: PreferredMethod;
+}
+type MessageIds = 'noOptionalAndDefaultTogether' | 'noOptionalAndDefaultTogetherRemoveMethod';
+export declare const noOptionalAndDefaultTogether: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,11 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const preferredMethods: readonly ["none", "default", "optional"];
+type PreferredMethod = (typeof preferredMethods)[number];
+interface Options {
+    preferredMethod: PreferredMethod;
+}
+type MessageIds = 'noOptionalAndDefaultTogether' | 'noOptionalAndDefaultTogetherRemoveMethod';
+export declare const noOptionalAndDefaultTogether: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,77 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+const preferredMethods = ['none', 'default', 'optional'];
+const defaultOptions = { preferredMethod: 'none' };
+export const noOptionalAndDefaultTogether = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'no-optional-and-default-together',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            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: isZodSchema, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                if (!isZodSchema(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));
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noThrowInRefine = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const is_zod_expression_js_1 = require("../utils/is-zod-expression.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.noThrowInRefine = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'no-throw-in-refine',
+    meta: {
+        type: 'problem',
+        docs: {
+            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, } = (0, track_zod_schema_imports_js_1.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;
+                }
+                if ((0, is_zod_expression_js_1.isZodExpressionEndingWithMethod)(node.callee, 'refine')) {
+                    const [callback] = node.arguments;
+                    if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                        checkNode(callback.body);
+                    }
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noThrowInRefine: ESLintUtils.RuleModule<"noThrowInRefine", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noThrowInRefine: ESLintUtils.RuleModule<"noThrowInRefine", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,81 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { isZodExpressionEndingWithMethod } from "../utils/is-zod-expression.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const noThrowInRefine = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'no-throw-in-refine',
+    meta: {
+        type: 'problem',
+        docs: {
+            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, } = 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) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                if (isZodExpressionEndingWithMethod(node.callee, 'refine')) {
+                    const [callback] = node.arguments;
+                    if (callback.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === AST_NODE_TYPES.FunctionExpression) {
+                        checkNode(callback.body);
+                    }
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnknownSchema = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.noUnknownSchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'no-unknown-schema',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            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, } = (0, track_zod_schema_imports_js_1.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',
+                    });
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noUnknownSchema: ESLintUtils.RuleModule<"noZUnknown", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noUnknownSchema: ESLintUtils.RuleModule<"noZUnknown", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,32 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const noUnknownSchema = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'no-unknown-schema',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            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',
+                    });
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferEnumOverLiteralUnion = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.preferEnumOverLiteralUnion = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'prefer-enum-over-literal-union',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            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, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchema = detectZodSchemaRootNode(node);
+                if ((zodSchema === null || zodSchema === void 0 ? void 0 : zodSchema.schemaType) !== 'union') {
+                    return;
+                }
+                const [unionArgument] = node.arguments;
+                if (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(node.callee.property, 'enum'),
+                            fixer.replaceText(node.arguments[0], `[${zodLiteralStrings.join(', ')}]`),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferEnumOverLiteralUnion: ESLintUtils.RuleModule<"useEnum", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const preferEnumOverLiteralUnion: ESLintUtils.RuleModule<"useEnum", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};