@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/prefer-params-over-parent-id.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * @fileoverview Enforce the use of event.params over .ref.parent.id in Firebase change handlers
+ * @author BluMint
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferParamsOverParentId = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const HANDLER_TYPES = new Set([
+    'DocumentChangeHandler',
+    'DocumentChangeHandlerTransaction',
+    'RealtimeDbChangeHandler',
+    'RealtimeDbChangeHandlerTransaction',
+]);
+exports.preferParamsOverParentId = (0, createRule_1.createRule)({
+    name: 'prefer-params-over-parent-id',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer handler params for parent IDs instead of traversing ref.parent.id so Firebase triggers stay aligned with path templates and type-safe.',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferParams: 'Accessing parent IDs through `ref.parent.id` bypasses the handler params and breaks when collection nesting changes. Use the params object for stable, typed IDs instead (destructure `const { params: { {{paramName}} } } = event` or read `params.{{paramName}}`).',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track functions that are Firebase change handlers
+        const handlerFunctions = new Set();
+        function findTypeAnnotationInContext(node) {
+            // Check variable declarator type annotation
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.parent.id.typeAnnotation) {
+                return node.parent.id.typeAnnotation;
+            }
+            // Check assignment expression with type annotation
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                node.parent.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.parent.left.typeAnnotation) {
+                return node.parent.left.typeAnnotation;
+            }
+            // Check property definition type annotation
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                node.parent.value === node) {
+                // Look up the tree for type annotation
+                let current = node.parent.parent;
+                while (current) {
+                    if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        current.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        current.id.typeAnnotation) {
+                        return current.id.typeAnnotation;
+                    }
+                    current = current.parent;
+                }
+            }
+            return undefined;
+        }
+        function isFirebaseChangeHandler(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.type !== utils_1.AST_NODE_TYPES.FunctionExpression &&
+                node.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                return false;
+            }
+            const typeAnnotation = findTypeAnnotationInContext(node);
+            if (!typeAnnotation) {
+                return false;
+            }
+            return checkTypeAnnotationForHandler(typeAnnotation.typeAnnotation);
+        }
+        function checkTypeAnnotationForHandler(typeNode) {
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return HANDLER_TYPES.has(typeNode.typeName.name);
+            }
+            return false;
+        }
+        function isParentIdAccess(node) {
+            // Check if this is a .ref.parent[.parent...].id pattern
+            if (node.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                node.property.name !== 'id') {
+                return { isMatch: false, depth: 0 };
+            }
+            const chain = [];
+            let current = node.object;
+            while (current && current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                if (current.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return { isMatch: false, depth: 0 };
+                }
+                chain.unshift(current.property.name);
+                current = current.object;
+            }
+            if (chain.length < 2) {
+                return { isMatch: false, depth: 0 };
+            }
+            const refIndex = chain.indexOf('ref');
+            if (refIndex === -1) {
+                return { isMatch: false, depth: 0 };
+            }
+            const parentSegment = chain.slice(refIndex + 1);
+            if (parentSegment.length === 0) {
+                return { isMatch: false, depth: 0 };
+            }
+            const invalidParent = parentSegment.some((segment) => segment !== 'parent');
+            if (invalidParent) {
+                return { isMatch: false, depth: 0 };
+            }
+            const depth = parentSegment.length;
+            return { isMatch: depth > 0, depth };
+        }
+        function findHandlerFunction(node) {
+            let current = node;
+            while (current) {
+                if (handlerFunctions.has(current)) {
+                    return current;
+                }
+                current = current.parent;
+            }
+            return null;
+        }
+        function hasOptionalChaining(node) {
+            let current = node;
+            while (current && current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                if (current.optional) {
+                    return true;
+                }
+                current = current.object;
+            }
+            return false;
+        }
+        function isParamsInScope(handlerNode) {
+            // Check if params is destructured from the event parameter
+            if (handlerNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                handlerNode.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                handlerNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                const firstParam = handlerNode.params[0];
+                if (!firstParam)
+                    return false;
+                // Check for destructuring pattern: ({ params }) or ({ data, params })
+                if (firstParam.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    return firstParam.properties.some((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'params') {
+                            return true;
+                        }
+                        return false;
+                    });
+                }
+                // Check for variable declarations inside the function that destructure params
+                if (handlerNode.body &&
+                    handlerNode.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    for (const statement of handlerNode.body.body) {
+                        if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                            for (const declarator of statement.declarations) {
+                                if (declarator.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                                    declarator.init &&
+                                    declarator.init.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    // Check if destructuring from event parameter
+                                    const eventParamName = firstParam.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? firstParam.name
+                                        : 'event';
+                                    if (declarator.init.name === eventParamName) {
+                                        return declarator.id.properties.some((prop) => {
+                                            if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                                prop.key.name === 'params') {
+                                                return true;
+                                            }
+                                            return false;
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        return {
+            // Track Firebase change handler functions
+            'FunctionDeclaration, FunctionExpression, ArrowFunctionExpression'(node) {
+                if (isFirebaseChangeHandler(node)) {
+                    handlerFunctions.add(node);
+                }
+            },
+            // Detect .ref.parent.id patterns
+            MemberExpression(node) {
+                const parentAccess = isParentIdAccess(node);
+                if (parentAccess.isMatch) {
+                    const handlerNode = findHandlerFunction(node);
+                    if (handlerNode) {
+                        const hasOptional = hasOptionalChaining(node);
+                        const paramsInScope = isParamsInScope(handlerNode);
+                        // Suggest different parameter names based on depth
+                        // Note: These conventions may vary by data model; adjust if needed
+                        const paramSuggestion = parentAccess.depth === 1
+                            ? 'userId'
+                            : parentAccess.depth === 2
+                                ? 'parentId'
+                                : `parent${parentAccess.depth}Id`;
+                        context.report({
+                            node,
+                            messageId: 'preferParams',
+                            data: {
+                                paramName: paramSuggestion,
+                            },
+                            fix: paramsInScope
+                                ? (fixer) => {
+                                    const replacement = hasOptional
+                                        ? `params?.${paramSuggestion}`
+                                        : `params.${paramSuggestion}`;
+                                    return fixer.replaceText(node, replacement);
+                                }
+                                : undefined,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-params-over-parent-id.js.map

package/lib/rules/prefer-settings-object.js

@@ -40,8 +40,8 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            tooManyParams: 'Function has too many parameters ({{count}}). Use a settings object instead.',
-            sameTypeParams: 'Function has multiple parameters of the same type. Use a settings object instead.',
+            tooManyParams: "Function accepts {{count}} positional parameters (limit {{minimum}}). Long positional lists hide each argument's meaning and make call sites easy to mis-order. Pass a single settings object so callers name each field and keep the call readable.",
+            sameTypeParams: 'Function receives {{paramCount}} positional parameters including multiple "{{type}}" values. Repeated types in positional arguments invite swapped values and force callers to remember parameter order. Replace the positional list with a settings object so each value is labeled and self-documenting.',
         },
     },
     defaultOptions: [defaultOptions],
@@ -60,10 +60,12 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                         ? typeNode.typeName.name
                         : 'unknown';
                     // If there are type parameters, include them in the type signature
-                    if (typeNode.typeParameters && typeNode.typeParameters.params.length > 0) {
+                    if (typeNode.typeParameters &&
+                        typeNode.typeParameters.params.length > 0) {
+                        const sourceCode = context.getSourceCode();
                         const typeParams = typeNode.typeParameters.params
-                            .map(param => param.type)
-                            .join('_');
+                            .map((param) => sourceCode.getText(param))
+                            .join(', ');
                         return `${typeName}<${typeParams}>`;
                     }
                     return typeName;
@@ -78,10 +80,12 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                         ? typeNode.typeName.name
                         : 'unknown';
                     // If there are type parameters, include them in the type signature
-                    if (typeNode.typeParameters && typeNode.typeParameters.params.length > 0) {
+                    if (typeNode.typeParameters &&
+                        typeNode.typeParameters.params.length > 0) {
+                        const sourceCode = context.getSourceCode();
                         const typeParams = typeNode.typeParameters.params
-                            .map(param => param.type)
-                            .join('_');
+                            .map((param) => sourceCode.getText(param))
+                            .join(', ');
                         return `${typeName}<${typeParams}>`;
                     }
                     return typeName;
@@ -96,17 +100,17 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             }
             return 'unknown';
         }
-        function hasSameTypeParameters(params) {
+        function findDuplicateParameterType(params) {
             const typeMap = new Map();
             for (const param of params) {
                 const type = getParameterType(param);
                 const count = (typeMap.get(type) || 0) + 1;
                 typeMap.set(type, count);
                 if (count > 1) {
-                    return true;
+                    return type;
                 }
             }
-            return false;
+            return null;
         }
         function isBuiltInOrThirdParty(node) {
             // Check if the node is part of a new expression (constructor call)
@@ -287,8 +291,10 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 // Check if the function name or its type annotation suggests it's a handler with transaction
                 if (functionName.includes('Transaction') ||
                     functionName.includes('WithTransaction') ||
-                    (node.parent.id.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                        node.parent.id.typeAnnotation.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.parent.id.typeAnnotation?.typeAnnotation.type ===
+                        utils_1.AST_NODE_TYPES.TSTypeReference &&
+                        node.parent.id.typeAnnotation.typeAnnotation.typeName.type ===
+                            utils_1.AST_NODE_TYPES.Identifier &&
                         (node.parent.id.typeAnnotation.typeAnnotation.typeName.name.includes('Transaction') ||
                             node.parent.id.typeAnnotation.typeAnnotation.typeName.name.includes('WithTransaction')))) {
                     return true;
@@ -306,16 +312,18 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 context.report({
                     node,
                     messageId: 'tooManyParams',
-                    data: { count: params.length },
+                    data: { count: params.length, minimum: minParams },
                 });
                 return;
             }
             // Then check for same type parameters if enabled
             if (finalOptions.checkSameTypeParameters && params.length >= 2) {
-                if (hasSameTypeParameters(params)) {
+                const duplicateType = findDuplicateParameterType(params);
+                if (duplicateType) {
                     context.report({
                         node,
                         messageId: 'sameTypeParams',
+                        data: { type: duplicateType, paramCount: params.length },
                     });
                 }
             }

package/lib/rules/prefer-type-alias-over-typeof-constant.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'preferTypeAlias' | 'defineTypeBeforeConstant';
+export declare const preferTypeAliasOverTypeofConstant: TSESLint.RuleModule<MessageIds, never[]>;

package/lib/rules/prefer-type-alias-over-typeof-constant.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferTypeAliasOverTypeofConstant = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const PAREN_TYPE = utils_1.AST_NODE_TYPES.TSParenthesizedType ??
+    'TSParenthesizedType';
+const isParenthesizedType = (node) => {
+    return node.type === PAREN_TYPE;
+};
+/** Utility to convert CONSTANT_CASE or snake/kebab to PascalCase */
+function toPascalCase(name) {
+    return name
+        .split(/[_-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join('');
+}
+/** Determine if a value initializer represents a function or class (which we should ignore). */
+function isFunctionOrClassInitializer(init) {
+    if (!init)
+        return false;
+    return (init.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        init.type === utils_1.AST_NODE_TYPES.ClassExpression);
+}
+/** Determine if node is a simple constant literal or object/array literal possibly with `as const` */
+function isConstantLikeInitializer(init) {
+    if (!init)
+        return false;
+    if (isFunctionOrClassInitializer(init))
+        return false;
+    switch (init.type) {
+        case utils_1.AST_NODE_TYPES.Literal:
+            return true;
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return init.expressions.length === 0;
+        case utils_1.AST_NODE_TYPES.ObjectExpression:
+            return true;
+        case utils_1.AST_NODE_TYPES.ArrayExpression:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+            return isConstantLikeInitializer(init.expression);
+        case utils_1.AST_NODE_TYPES.UnaryExpression: {
+            // treat unary constants (e.g., -1) as constant-like; exclude typeof
+            if (init.operator === 'typeof')
+                return false;
+            return isConstantLikeInitializer(init.argument);
+        }
+        default:
+            return false;
+    }
+}
+/** Traverse a TSType and collect referenced identifier names (e.g., A, B in A | B). */
+function collectReferencedTypeNames(node, acc = new Set()) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeReference: {
+            if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                acc.add(node.typeName.name);
+            }
+            if (node.typeParameters) {
+                for (const p of node.typeParameters.params)
+                    collectReferencedTypeNames(p, acc);
+            }
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+        case utils_1.AST_NODE_TYPES.TSIntersectionType: {
+            for (const t of node.types)
+                collectReferencedTypeNames(t, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSArrayType: {
+            const arr = node;
+            collectReferencedTypeNames(arr.elementType, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSTypeOperator: {
+            const op = node;
+            if (op.typeAnnotation)
+                collectReferencedTypeNames(op.typeAnnotation, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSTupleType: {
+            const tup = node;
+            for (const e of tup.elementTypes)
+                collectReferencedTypeNames(e, acc);
+            break;
+        }
+        default: {
+            if (isParenthesizedType(node)) {
+                collectReferencedTypeNames(node.typeAnnotation, acc);
+            }
+            break;
+        }
+    }
+    return acc;
+}
+/** Collects module-level consts and type aliases for quick lookup */
+function collectTopLevelContext(program) {
+    const topLevelConstInitByName = new Map();
+    const topLevelConstNodeByName = new Map();
+    const typeAliasByName = new Map();
+    const importedValueNames = new Set();
+    const importedTypeNames = new Set();
+    for (const stmt of program.body) {
+        if (stmt.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+            const isTypeImport = stmt.importKind === 'type';
+            for (const spec of stmt.specifiers) {
+                // import type { Foo } from '...'
+                // import { Foo } from '...' as value import
+                if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                    if (isTypeImport || spec.importKind === 'type') {
+                        importedTypeNames.add(spec.local.name);
+                    }
+                    else {
+                        importedValueNames.add(spec.local.name);
+                    }
+                }
+                else if (spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                    if (isTypeImport) {
+                        importedTypeNames.add(spec.local.name);
+                    }
+                    else {
+                        importedValueNames.add(spec.local.name);
+                    }
+                }
+                else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                    // Namespace imports expose names via MemberExpression; not tracked individually
+                }
+            }
+        }
+        else if (stmt.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+            stmt.kind === 'const') {
+            for (const decl of stmt.declarations) {
+                if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    topLevelConstInitByName.set(decl.id.name, decl.init ?? null);
+                    topLevelConstNodeByName.set(decl.id.name, decl);
+                }
+            }
+        }
+        else if (stmt.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+            typeAliasByName.set(stmt.id.name, stmt);
+        }
+        else if (stmt.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+            stmt.declaration) {
+            // Handle exported declarations: export const FOO = ...; export type Foo = ...
+            const decl = stmt.declaration;
+            if (decl.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                decl.kind === 'const') {
+                for (const d of decl.declarations) {
+                    if (d.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        topLevelConstInitByName.set(d.id.name, d.init ?? null);
+                        topLevelConstNodeByName.set(d.id.name, d);
+                    }
+                }
+            }
+            else if (decl.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                typeAliasByName.set(decl.id.name, decl);
+            }
+        }
+    }
+    return {
+        topLevelConstInitByName,
+        topLevelConstNodeByName,
+        typeAliasByName,
+        importedValueNames,
+        importedTypeNames,
+    };
+}
+exports.preferTypeAliasOverTypeofConstant = (0, createRule_1.createRule)({
+    name: 'prefer-type-alias-over-typeof-constant',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer named type aliases over `typeof` on same-file global constants; ensure types are declared before constants.',
+            recommended: 'error',
+        },
+        hasSuggestions: false,
+        schema: [],
+        messages: {
+            preferTypeAlias: 'Type derived from same-file constant "{{constName}}" couples the type to its runtime value and scatters literal unions across the file. Create a named alias such as "{{suggested}}" and reference that alias instead of `typeof {{constName}}` so the type stays stable even if the value changes.',
+            defineTypeBeforeConstant: 'Type alias "{{typeName}}" appears after constant "{{constName}}", which hides the shape from readers and risks using an undeclared alias. Declare "{{typeName}}" before "{{constName}}" so the type is visible where it is consumed and can be reused consistently.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        let collected;
+        return {
+            Program(program) {
+                collected = collectTopLevelContext(program);
+            },
+            // Enforce that type aliases referenced by const annotations appear before the const
+            VariableDeclarator(node) {
+                if (!collected)
+                    return;
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const constName = node.id.name;
+                // Only for top-level consts
+                const decl = collected.topLevelConstNodeByName.get(constName);
+                if (!decl || decl !== node)
+                    return;
+                const parentDecl = node.parent;
+                if (!parentDecl || parentDecl.kind !== 'const')
+                    return;
+                const typeAnn = node.id.typeAnnotation?.typeAnnotation;
+                if (!typeAnn)
+                    return;
+                for (const typeName of collectReferencedTypeNames(typeAnn)) {
+                    // If imported type, allow any order
+                    if (collected.importedTypeNames.has(typeName))
+                        continue;
+                    const typeDecl = collected.typeAliasByName.get(typeName);
+                    if (typeDecl && typeDecl.range[0] > parentDecl.range[0]) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'defineTypeBeforeConstant',
+                            data: { typeName, constName },
+                        });
+                    }
+                }
+            },
+            // Core rule: flag `typeof CONST` when CONST is a same-file top-level const and constant-like
+            TSTypeQuery(node) {
+                if (!collected)
+                    return;
+                // Skip `keyof typeof X`
+                if (node.parent &&
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                    node.parent.operator === 'keyof') {
+                    return;
+                }
+                if (node.exprName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const name = node.exprName.name;
+                // Imported values: do not enforce (may suggest in future)
+                if (collected.importedValueNames.has(name)) {
+                    return;
+                }
+                const init = collected.topLevelConstInitByName.get(name);
+                if (init === undefined) {
+                    // Not a top-level const in this file
+                    return;
+                }
+                if (!isConstantLikeInitializer(init)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'preferTypeAlias',
+                    data: { constName: name, suggested: toPascalCase(name) },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-type-alias-over-typeof-constant.js.map

package/lib/rules/prefer-url-tostring-over-tojson.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const preferUrlToStringOverToJson: TSESLint.RuleModule<'preferToString', never[]>;