@blumintinc/eslint-plugin-blumint 1.8.1 → 1.9.0

package/lib/index.js

@@ -96,10 +96,11 @@ const enforce_css_media_queries_1 = require("./rules/enforce-css-media-queries")
 const omit_index_html_1 = require("./rules/omit-index-html");
 const enforce_id_capitalization_1 = require("./rules/enforce-id-capitalization");
 const no_unused_usestate_1 = require("./rules/no-unused-usestate");
+const no_uuidv4_base62_as_key_1 = require("./rules/no-uuidv4-base62-as-key");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.8.1',
+        version: '1.9.0',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -134,6 +135,7 @@ module.exports = {
                 '@blumintinc/blumint/no-misused-switch-case': 'error',
                 '@blumintinc/blumint/no-unpinned-dependencies': 'error',
                 '@blumintinc/blumint/no-unused-props': 'error',
+                '@blumintinc/blumint/no-uuidv4-base62-as-key': 'error',
                 //'@blumintinc/blumint/no-useless-fragment': 'error',
                 //'@blumintinc/blumint/prefer-fragment-shorthand': 'error',
                 '@blumintinc/blumint/prefer-type-over-interface': 'error',
@@ -235,6 +237,7 @@ module.exports = {
         'no-unpinned-dependencies': no_unpinned_dependencies_1.noUnpinnedDependencies,
         'no-unused-props': no_unused_props_1.noUnusedProps,
         'no-useless-fragment': no_useless_fragment_1.noUselessFragment,
+        'no-uuidv4-base62-as-key': no_uuidv4_base62_as_key_1.noUuidv4Base62AsKey,
         'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
         'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
         'require-memo': require_memo_1.requireMemo,

package/lib/rules/enforce-assertSafe-object-key.js

@@ -26,7 +26,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
         const addAssertSafeImport = (fixer) => {
             const program = context.getSourceCode().ast;
             const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-            const importStatement = "import { assertSafe } from 'utils/assertions';\n";
+            const importStatement = "import { assertSafe } from 'functions/src/util/assertSafe';\n";
             if (firstImport) {
                 return fixer.insertTextBefore(firstImport, importStatement);
             }

package/lib/rules/enforce-id-capitalization.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceIdCapitalization = void 0;
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
 /**
  * This rule ensures consistency in user-facing text by enforcing the use of "ID"
  * instead of "id" when referring to identifiers in UI labels, instructions,
@@ -26,12 +27,51 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         // Regular expression to match standalone "id" surrounded by whitespace or punctuation
         // This ensures we only match "id" as a word, not as part of another word
         const idRegex = /(^|\s|[.,;:!?'"()\[\]{}])id(\s|$|[.,;:!?'"()\[\]{}])/g;
+        /**
+         * Check if a node is in a context that should be excluded from the rule
+         * (e.g., parameter names, property names, type definitions)
+         */
+        function isExcludedContext(node) {
+            // Check if the node is a property of an object pattern (destructuring)
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) &&
+                node.parent.key === node) {
+                return true;
+            }
+            // Check if the node is a parameter name
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                node.parent.params.includes(node)) {
+                return true;
+            }
+            // Check if the node is part of a type definition
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.TSPropertySignature ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSParameterProperty ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference)) {
+                return true;
+            }
+            // Check if the node is a variable name
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id === node) {
+                return true;
+            }
+            return false;
+        }
         /**
          * Check if a string contains "id" as a standalone word and report if found
          */
         function checkForIdInString(node, value) {
             if (typeof value !== 'string')
                 return;
+            // Skip checking if the node is in an excluded context
+            if (isExcludedContext(node))
+                return;
             // Reset the regex lastIndex to ensure consistent behavior
             idRegex.lastIndex = 0;
             // Check if the string contains "id" as a standalone word
@@ -45,13 +85,13 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
                     node,
                     messageId: 'enforceIdCapitalization',
                     fix: (fixer) => {
-                        if (node.type === 'Literal') {
+                        if (node.type === utils_1.AST_NODE_TYPES.Literal) {
                             return fixer.replaceText(node, JSON.stringify(fixedText));
                         }
-                        else if (node.type === 'JSXText') {
+                        else if (node.type === utils_1.AST_NODE_TYPES.JSXText) {
                             return fixer.replaceText(node, fixedText);
                         }
-                        else if (node.type === 'TemplateElement') {
+                        else if (node.type === utils_1.AST_NODE_TYPES.TemplateElement) {
                             return fixer.replaceText(node, fixedText);
                         }
                         return fixer.replaceText(node, JSON.stringify(fixedText));

package/lib/rules/enforce-object-literal-as-const.js

@@ -18,6 +18,36 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        /**
+         * Checks if the node is inside a React hook like useMemo
+         */
+        function isInsideReactHook(ancestors) {
+            for (let i = 0; i < ancestors.length; i++) {
+                const ancestor = ancestors[i];
+                // Check for CallExpression (function call)
+                if (ancestor.type === 'CallExpression') {
+                    const callee = ancestor.callee;
+                    // Check if it's a hook like useMemo, useCallback, etc.
+                    if (callee.type === 'Identifier' &&
+                        (callee.name === 'useMemo' ||
+                            callee.name === 'useCallback' ||
+                            callee.name.startsWith('use'))) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        /**
+         * Checks if an array contains object literals that might be used as component props
+         */
+        function isArrayWithObjectLiterals(node) {
+            if (node.type !== 'ArrayExpression') {
+                return false;
+            }
+            // Check if any element in the array is an object literal
+            return node.elements.some((elem) => elem !== null && elem.type === 'ObjectExpression');
+        }
         return {
             ReturnStatement(node) {
                 // Skip if there's no argument in the return statement
@@ -66,6 +96,13 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                         argument.elements.some((elem) => elem !== null && elem.type === 'SpreadElement'))) {
                     return;
                 }
+                // Skip arrays with object literals inside React hooks (likely component props)
+                if (isInsideReactHook(ancestors) &&
+                    isArrayWithObjectLiterals(argument.type === 'TSAsExpression'
+                        ? argument.expression
+                        : argument)) {
+                    return;
+                }
                 // Report the issue and provide a fix
                 context.report({
                     node,

package/lib/rules/enforce-positive-naming.js

@@ -3,60 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforcePositiveNaming = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-// Common negative prefixes and words to detect
-const NEGATIVE_PREFIXES = ['not', 'no', 'non', 'un', 'in', 'dis'];
-const NEGATIVE_WORDS = [
-    'invalid',
-    'disabled',
-    'incomplete',
-    'unpaid',
-    'inactive',
-    'disallowed',
-    'unauthorized',
-    'unverified',
-    'prevent',
-    'avoid',
-    'block',
-    'deny',
-    'reject',
-    'exclude',
-    'fail',
-    'missing',
-    'forbidden',
-    'impossible',
-    'error',
-    'broken',
-    'banned',
-    'restricted',
-    'limitation',
-    'limitation',
-    'blocked',
-    'prohibited',
-];
-// Whitelist of acceptable negative terms (technical terms, common patterns)
-const ALLOWED_NEGATIVE_TERMS = new Set([
-    'isNaN',
-    'isNull',
-    'isUndefined',
-    'isEmpty',
-    'isOffline',
-    'isMissing',
-    'isOutOfStock',
-    'isOutOfBounds',
-    'isOffPeak',
-    'isNoticeable',
-    'hasNotification',
-    'isNoteworthy',
-    'isNone',
-    'isNegative',
-    'isNeutral',
-    'isNotification',
-    'isNote',
-    'hasNote',
-]);
-// Map of negative terms to suggested positive alternatives
-const POSITIVE_ALTERNATIVES = {
-    // Prefixes
+// Common negative prefixes for boolean variables
+const BOOLEAN_NEGATIVE_PREFIXES = ['not', 'no', 'non', 'un', 'in', 'dis'];
+// Map of negative boolean terms to suggested positive alternatives
+const BOOLEAN_POSITIVE_ALTERNATIVES = {
+    // Boolean prefixes
     'isNot': ['is'],
     'isUn': ['is'],
     'isDis': ['is'],
@@ -68,54 +19,13 @@ const POSITIVE_ALTERNATIVES = {
     'shouldNot': ['should'],
     'willNot': ['will'],
     'doesNot': ['does'],
-    // Words
-    'isInvalid': ['isValid'],
-    'isDisabled': ['isEnabled'],
-    'isIncomplete': ['isComplete'],
-    'isUnpaid': ['isPaid', 'hasPaid'],
-    'isInactive': ['isActive'],
-    'isDisallowed': ['isAllowed'],
-    'isUnauthorized': ['isAuthorized'],
-    'isUnverified': ['isVerified'],
-    'isImpossible': ['isPossible'],
-    'isError': ['isSuccess', 'isValid'],
-    'isBroken': ['isWorking', 'isFunctional'],
-    'isBanned': ['isAllowed', 'isPermitted'],
-    'isRestricted': ['isAllowed', 'isAccessible'],
-    'isBlocked': ['isAllowed', 'isAccessible'],
-    'isProhibited': ['isAllowed', 'isPermitted'],
-    'prevent': ['allow', 'enable'],
-    'avoid': ['use', 'prefer'],
-    'block': ['allow', 'permit'],
-    'deny': ['allow', 'grant'],
-    'reject': ['accept', 'approve'],
-    'exclude': ['include'],
-    'fail': ['succeed', 'pass'],
-    'missing': ['present', 'available'],
-    'forbidden': ['allowed', 'permitted'],
-    'disabled': ['enabled'],
-    'incomplete': ['complete'],
-    'invalid': ['valid'],
-    'disallowed': ['allowed'],
-    'unauthorized': ['authorized'],
-    'unverified': ['verified'],
-    'inactive': ['active'],
-    'disabledFeatures': ['enabledFeatures'],
-    'inactiveUsers': ['activeUsers'],
-    'disableFeature': ['enableFeature'],
-    'disableAccount': ['enableAccount'],
-    'blockUser': ['allowUser'],
-    'preventAccess': ['allowAccess', 'enableAccess'],
-    'restrictAccess': ['allowAccess', 'grantAccess'],
-    'limitations': ['capabilities', 'features'],
-    'limitation': ['capability', 'feature'],
 };
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce positive variable naming patterns and avoid negative naming',
+            description: 'Enforce positive naming for boolean variables and avoid negations',
             recommended: 'error',
         },
         schema: [],
@@ -141,72 +51,43 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             return {};
         }
         /**
-         * Check if a name has negative connotations
+         * Check if a name has boolean negative naming
          */
-        function hasNegativeNaming(name) {
-            // Skip checking if the name is in the whitelist
-            if (ALLOWED_NEGATIVE_TERMS.has(name)) {
-                return { isNegative: false, alternatives: [] };
-            }
+        function hasBooleanNegativeNaming(name) {
             // Check for exact matches in our alternatives map first
-            if (POSITIVE_ALTERNATIVES[name]) {
-                return { isNegative: true, alternatives: POSITIVE_ALTERNATIVES[name] };
+            if (BOOLEAN_POSITIVE_ALTERNATIVES[name]) {
+                return { isNegative: true, alternatives: BOOLEAN_POSITIVE_ALTERNATIVES[name] };
             }
-            // Check for negative prefixes
-            for (const prefix of NEGATIVE_PREFIXES) {
-                // Check for patterns like isNot, hasNo, canNot, etc.
-                const prefixPatterns = [
-                    { pattern: new RegExp(`^is${prefix}`, 'i'), key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^has${prefix}`, 'i'), key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^can${prefix}`, 'i'), key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^should${prefix}`, 'i'), key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^will${prefix}`, 'i'), key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^does${prefix}`, 'i'), key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                ];
-                for (const { pattern, key } of prefixPatterns) {
-                    if (pattern.test(name)) {
-                        // If we have a direct match for this pattern (like isNotVerified -> isVerified)
-                        const directMatch = POSITIVE_ALTERNATIVES[name];
-                        if (directMatch) {
-                            return { isNegative: true, alternatives: directMatch };
-                        }
-                        const alternatives = POSITIVE_ALTERNATIVES[key] || [];
-                        if (alternatives.length > 0) {
-                            // Suggest the positive version with the rest of the name
-                            const restOfName = name.replace(pattern, '');
-                            const suggestedAlternatives = alternatives.map(alt => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
-                            return { isNegative: true, alternatives: suggestedAlternatives };
+            // Check for negative prefixes in boolean-like variables
+            if (name.startsWith('is') || name.startsWith('has') || name.startsWith('can') ||
+                name.startsWith('should') || name.startsWith('will') || name.startsWith('does')) {
+                for (const prefix of BOOLEAN_NEGATIVE_PREFIXES) {
+                    // Check for patterns like isNot, hasNo, canNot, etc.
+                    const prefixPatterns = [
+                        { pattern: new RegExp(`^is${prefix}`, 'i'), key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^has${prefix}`, 'i'), key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^can${prefix}`, 'i'), key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^should${prefix}`, 'i'), key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^will${prefix}`, 'i'), key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^does${prefix}`, 'i'), key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                    ];
+                    for (const { pattern, key } of prefixPatterns) {
+                        if (pattern.test(name)) {
+                            // If we have a direct match for this pattern (like isNotVerified -> isVerified)
+                            const directMatch = BOOLEAN_POSITIVE_ALTERNATIVES[name];
+                            if (directMatch) {
+                                return { isNegative: true, alternatives: directMatch };
+                            }
+                            const alternatives = BOOLEAN_POSITIVE_ALTERNATIVES[key] || [];
+                            if (alternatives.length > 0) {
+                                // Suggest the positive version with the rest of the name
+                                const restOfName = name.replace(pattern, '');
+                                const suggestedAlternatives = alternatives.map(alt => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
+                                return { isNegative: true, alternatives: suggestedAlternatives };
+                            }
+                            return { isNegative: true, alternatives: ['a positive alternative'] };
                         }
-                        return { isNegative: true, alternatives: ['a positive alternative'] };
-                    }
-                }
-            }
-            // Check for exact negative words
-            for (const word of NEGATIVE_WORDS) {
-                if (name.toLowerCase() === word.toLowerCase()) {
-                    const alternatives = POSITIVE_ALTERNATIVES[word] || [];
-                    return {
-                        isNegative: true,
-                        alternatives: alternatives.length ? alternatives : ['a positive alternative']
-                    };
-                }
-            }
-            // Check for negative words in camelCase/PascalCase
-            for (const word of NEGATIVE_WORDS) {
-                // Match the word at the beginning or after a capital letter
-                const pattern = new RegExp(`(^|[A-Z])${word}($|[A-Z])`, 'i');
-                if (pattern.test(name)) {
-                    // For compound names like isInvalid, check if we have a specific suggestion
-                    const exactMatch = `is${word.charAt(0).toUpperCase() + word.slice(1)}`;
-                    if (POSITIVE_ALTERNATIVES[exactMatch]) {
-                        return { isNegative: true, alternatives: POSITIVE_ALTERNATIVES[exactMatch] };
                     }
-                    // Otherwise suggest general alternatives for the negative word
-                    const alternatives = POSITIVE_ALTERNATIVES[word] || [];
-                    return {
-                        isNegative: true,
-                        alternatives: alternatives.length ? alternatives : ['a positive alternative']
-                    };
                 }
             }
             return { isNegative: false, alternatives: [] };
@@ -220,14 +101,41 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
             return String(alternatives);
         }
+        /**
+         * Check if a node is likely to be a boolean
+         */
+        function isBooleanLike(node) {
+            // Check if the node has a boolean type annotation
+            if (node.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                return true;
+            }
+            // Check if the node is initialized with a boolean literal
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.init?.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.parent.init.value === 'boolean') {
+                return true;
+            }
+            // Check if the node has a name that suggests it's a boolean
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                (node.name.startsWith('is') || node.name.startsWith('has') ||
+                    node.name.startsWith('can') || node.name.startsWith('should') ||
+                    node.name.startsWith('will') || node.name.startsWith('does'))) {
+                return true;
+            }
+            return false;
+        }
         /**
          * Check variable declarations for negative naming
          */
         function checkVariableDeclaration(node) {
             if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean-like variables
+            if (!isBooleanLike(node.id) && !isBooleanLike(node))
+                return;
             const variableName = node.id.name;
-            const { isNegative, alternatives } = hasNegativeNaming(variableName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(variableName);
             if (isNegative) {
                 context.report({
                     node: node.id,
@@ -263,7 +171,10 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
             if (!functionName)
                 return;
-            const { isNegative, alternatives } = hasNegativeNaming(functionName);
+            // Only check boolean-returning functions
+            if (!isBooleanLike(node.id || node))
+                return;
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(functionName);
             if (isNegative) {
                 context.report({
                     node: node.id || node,
@@ -281,8 +192,11 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkMethodDefinition(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean-returning methods
+            if (!isBooleanLike(node.key))
+                return;
             const methodName = node.key.name;
-            const { isNegative, alternatives } = hasNegativeNaming(methodName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(methodName);
             if (isNegative) {
                 context.report({
                     node: node.key,
@@ -300,8 +214,11 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkProperty(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean properties
+            if (!isBooleanLike(node.key))
+                return;
             const propertyName = node.key.name;
-            const { isNegative, alternatives } = hasNegativeNaming(propertyName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);
             if (isNegative) {
                 context.report({
                     node: node.key,
@@ -319,8 +236,12 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkPropertySignature(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean properties
+            if (!isBooleanLike(node.key) &&
+                !(node.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword))
+                return;
             const propertyName = node.key.name;
-            const { isNegative, alternatives } = hasNegativeNaming(propertyName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);
             if (isNegative) {
                 context.report({
                     node: node.key,
@@ -338,8 +259,11 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkParameter(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean parameters
+            if (!isBooleanLike(node))
+                return;
             const paramName = node.name;
-            const { isNegative, alternatives } = hasNegativeNaming(paramName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(paramName);
             if (isNegative) {
                 context.report({
                     node,

package/lib/rules/enforce-singular-type-names.js

@@ -38,7 +38,7 @@ exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
             if (name.length < 3)
                 return false;
             // Skip checking if name ends with 'Props' or 'Params'
-            if (name.endsWith('Props') || name.endsWith('Params'))
+            if (name.endsWith('Props') || name.endsWith('Params') || name.endsWith('Options') || name.endsWith('Settings'))
                 return false;
             // Skip checking if name is already singular according to pluralize
             if (pluralize.isSingular(name))

package/lib/rules/no-hungarian.d.ts

@@ -1,5 +1 @@
-type Options = {
-    allowClassInstances?: boolean;
-};
-export declare const noHungarian: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noHungarian", [Options], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
-export {};
+export declare const noHungarian: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noHungarian", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;