eslint-plugin-zod 1.3.0 → 3.0.0

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consistentImportSource = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const ZOD_IMPORT_SOURCES = [
+    'zod',
+    'zod/mini',
+    'zod/v4',
+    'zod/v4-mini',
+    'zod/v3',
+];
+exports.consistentImportSource = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'consistent-import-source',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent source from Zod 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'] }],
+    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));
+                        },
+                    })),
+                });
+            },
+        };
+    },
+});

package/dist/rules/consistent-import-source.d.cts

@@ -0,0 +1,10 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const ZOD_IMPORT_SOURCES: readonly ["zod", "zod/mini", "zod/v4", "zod/v4-mini", "zod/v3"];
+type ZodImportSource = (typeof ZOD_IMPORT_SOURCES)[number];
+type MessageIds = 'sourceNotAllowed' | 'replaceSource';
+export declare const consistentImportSource: TSESLint.RuleModule<MessageIds, [{
+    sources: Array<ZodImportSource>;
+}], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/consistent-import-source.d.ts

@@ -0,0 +1,10 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const ZOD_IMPORT_SOURCES: readonly ["zod", "zod/mini", "zod/v4", "zod/v4-mini", "zod/v3"];
+type ZodImportSource = (typeof ZOD_IMPORT_SOURCES)[number];
+type MessageIds = 'sourceNotAllowed' | 'replaceSource';
+export declare const consistentImportSource: TSESLint.RuleModule<MessageIds, [{
+    sources: Array<ZodImportSource>;
+}], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,70 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+const ZOD_IMPORT_SOURCES = [
+    'zod',
+    'zod/mini',
+    'zod/v4',
+    'zod/v4-mini',
+    'zod/v3',
+];
+export const consistentImportSource = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'consistent-import-source',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent source from Zod 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'] }],
+    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));
+                        },
+                    })),
+                });
+            },
+        };
+    },
+});

package/dist/rules/consistent-object-schema-type.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consistentObjectSchemaType = 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 ZOD_OBJECT_METHODS = ['object', 'looseObject', 'strictObject'];
+const defaultOptions = { allow: ['object'] };
+exports.consistentObjectSchemaType = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'consistent-object-schema-type',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent usage of Zod schema methods',
+        },
+        messages: {
+            consistentMethod: "Inconsistent Zod object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+            useMethod: "Replace with '{{expected}}'.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allow: {
+                        type: 'array',
+                        description: 'Decides which object methods are allowed',
+                        items: {
+                            type: 'string',
+                            enum: [...ZOD_OBJECT_METHODS],
+                        },
+                        minItems: 1,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [{ allow: allowedList }]) {
+        const { importDeclarationListener, detectZodSchemaRootNode, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                const schemaType = zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType;
+                if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) {
+                    return;
+                }
+                if (allowedList.includes(schemaType)) {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    context.report({
+                        node,
+                        messageId: 'consistentMethod',
+                        data: { actual: schemaType, allowedList: allowedList.join(',') },
+                    });
+                    return;
+                }
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    context.report({
+                        node,
+                        messageId: 'consistentMethod',
+                        data: {
+                            actual: schemaType,
+                            allowedList: allowedList.join(','),
+                        },
+                        suggest: allowedList.map((it) => ({
+                            messageId: 'useMethod',
+                            data: { expected: it },
+                            fix(fixer) {
+                                return fixer.replaceText(callee.property, it);
+                            },
+                        })),
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/consistent-object-schema-type.d.cts

@@ -0,0 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const ZOD_OBJECT_METHODS: readonly ["object", "looseObject", "strictObject"];
+type ZodObjectMethod = (typeof ZOD_OBJECT_METHODS)[number];
+interface Options {
+    allow: Array<ZodObjectMethod>;
+}
+type MessageIds = 'consistentMethod' | 'useMethod';
+export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/consistent-object-schema-type.d.ts

@@ -0,0 +1,11 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const ZOD_OBJECT_METHODS: readonly ["object", "looseObject", "strictObject"];
+type ZodObjectMethod = (typeof ZOD_OBJECT_METHODS)[number];
+interface Options {
+    allow: Array<ZodObjectMethod>;
+}
+type MessageIds = 'consistentMethod' | 'useMethod';
+export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/consistent-object-schema-type.js

@@ -0,0 +1,80 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+const ZOD_OBJECT_METHODS = ['object', 'looseObject', 'strictObject'];
+const defaultOptions = { allow: ['object'] };
+export const consistentObjectSchemaType = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'consistent-object-schema-type',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent usage of Zod schema methods',
+        },
+        messages: {
+            consistentMethod: "Inconsistent Zod object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+            useMethod: "Replace with '{{expected}}'.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allow: {
+                        type: 'array',
+                        description: 'Decides which object methods are allowed',
+                        items: {
+                            type: 'string',
+                            enum: [...ZOD_OBJECT_METHODS],
+                        },
+                        minItems: 1,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [{ allow: allowedList }]) {
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                const schemaType = zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType;
+                if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) {
+                    return;
+                }
+                if (allowedList.includes(schemaType)) {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type === AST_NODE_TYPES.Identifier) {
+                    context.report({
+                        node,
+                        messageId: 'consistentMethod',
+                        data: { actual: schemaType, allowedList: allowedList.join(',') },
+                    });
+                    return;
+                }
+                if (callee.type === AST_NODE_TYPES.MemberExpression) {
+                    context.report({
+                        node,
+                        messageId: 'consistentMethod',
+                        data: {
+                            actual: schemaType,
+                            allowedList: allowedList.join(','),
+                        },
+                        suggest: allowedList.map((it) => ({
+                            messageId: 'useMethod',
+                            data: { expected: it },
+                            fix(fixer) {
+                                return fixer.replaceText(callee.property, it);
+                            },
+                        })),
+                    });
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAnySchema = 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.noAnySchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'no-any-schema',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow usage of `z.any()` in Zod schemas',
+        },
+        messages: {
+            noZAny: 'Using `z.any()` is not allowed. Please use a more specific schema.',
+            useUnknown: 'Replace `z.any()` with `z.unknown()`',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (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) !== 'any') {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    context.report({
+                        node,
+                        messageId: 'noZAny',
+                    });
+                    return;
+                }
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const [{ node: schemaMethod }] = collectZodChainMethods(node);
+                    const schemaMethodCallee = schemaMethod.callee;
+                    if (schemaMethodCallee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        schemaMethodCallee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        context.report({
+                            node,
+                            messageId: 'noZAny',
+                            suggest: [
+                                {
+                                    messageId: 'useUnknown',
+                                    fix(fixer) {
+                                        return fixer.replaceText(schemaMethodCallee.property, 'unknown');
+                                    },
+                                },
+                            ],
+                        });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'noZAny',
+                    });
+                }
+            },
+        };
+    },
+});

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

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

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

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

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

@@ -0,0 +1,63 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const noAnySchema = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'no-any-schema',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow usage of `z.any()` in Zod schemas',
+        },
+        messages: {
+            noZAny: 'Using `z.any()` is not allowed. Please use a more specific schema.',
+            useUnknown: 'Replace `z.any()` with `z.unknown()`',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(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) !== 'any') {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type === AST_NODE_TYPES.Identifier) {
+                    context.report({
+                        node,
+                        messageId: 'noZAny',
+                    });
+                    return;
+                }
+                if (callee.type === AST_NODE_TYPES.MemberExpression) {
+                    const [{ node: schemaMethod }] = collectZodChainMethods(node);
+                    const schemaMethodCallee = schemaMethod.callee;
+                    if (schemaMethodCallee.type === AST_NODE_TYPES.MemberExpression &&
+                        schemaMethodCallee.property.type === AST_NODE_TYPES.Identifier) {
+                        context.report({
+                            node,
+                            messageId: 'noZAny',
+                            suggest: [
+                                {
+                                    messageId: 'useUnknown',
+                                    fix(fixer) {
+                                        return fixer.replaceText(schemaMethodCallee.property, 'unknown');
+                                    },
+                                },
+                            ],
+                        });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'noZAny',
+                    });
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noEmptyCustomSchema = 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.noEmptyCustomSchema = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'no-empty-custom-schema',
+    meta: {
+        hasSuggestions: false,
+        type: 'suggestion',
+        docs: {
+            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, } = (0, track_zod_schema_imports_js_1.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',
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-empty-custom-schema.d.cts

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

package/dist/rules/no-empty-custom-schema.d.ts

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

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

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

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noNumberSchemaWithInt = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const get_outermost_call_js_1 = require("../utils/get-outermost-call.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.noNumberSchemaWithInt = utils_1.ESLintUtils.RuleCreator(meta_js_1.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, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                var _a;
+                const outer = (_a = (0, get_outermost_call_js_1.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);
+                    },
+                });
+            },
+        };
+    },
+});