@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

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

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceAssertSafeObjectKey = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
+    name: 'enforce-assertSafe-object-key',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce the use of assertSafe(id) when accessing object properties with computed keys that involve string interpolation or explicit string conversion.',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useAssertSafe: 'Use assertSafe() for object key access to ensure safe property access. Replace `obj[String(id)]` or `obj[`${id}`]` with `obj[assertSafe(id)]`.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        let hasAssertSafeImport = false;
+        /**
+         * Helper function to add assertSafe import if needed
+         */
+        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";
+            if (firstImport) {
+                return fixer.insertTextBefore(firstImport, importStatement);
+            }
+            else {
+                return fixer.insertTextBefore(program.body[0], importStatement);
+            }
+        };
+        /**
+         * Helper function to create fixes for a node
+         */
+        const createFixes = (fixer, node, argText) => {
+            const fixes = [];
+            // Add import if not present
+            if (!hasAssertSafeImport) {
+                fixes.push(addAssertSafeImport(fixer));
+                hasAssertSafeImport = true;
+            }
+            // Replace the node with assertSafe(argText)
+            fixes.push(fixer.replaceText(node, `assertSafe(${argText})`));
+            return fixes;
+        };
+        return {
+            ImportDeclaration(node) {
+                // Check if assertSafe is already imported
+                if (node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    specifier.imported.name === 'assertSafe')) {
+                    hasAssertSafeImport = true;
+                }
+            },
+            // Handle computed property in object destructuring
+            Property(node) {
+                if (node.computed && node.key) {
+                    const key = node.key;
+                    // Check for String(id) pattern
+                    if (key.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        key.callee.name === 'String') {
+                        context.report({
+                            node: key,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const arg = key.arguments[0];
+                                const argText = context.getSourceCode().getText(arg);
+                                return createFixes(fixer, key, argText);
+                            },
+                        });
+                    }
+                    // Check for template literals like `${id}`
+                    if (key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                        key.expressions.length === 1 &&
+                        key.quasis.length === 2 &&
+                        key.quasis[0].value.raw === '' &&
+                        key.quasis[1].value.raw === '') {
+                        context.report({
+                            node: key,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const expr = key.expressions[0];
+                                const exprText = context.getSourceCode().getText(expr);
+                                return createFixes(fixer, key, exprText);
+                            },
+                        });
+                    }
+                }
+            },
+            // Handle binary expressions like 'key' in obj
+            BinaryExpression(node) {
+                if (node.operator === 'in') {
+                    const left = node.left;
+                    // Check for String(id) pattern
+                    if (left.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        left.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        left.callee.name === 'String') {
+                        context.report({
+                            node: left,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const arg = left.arguments[0];
+                                const argText = context.getSourceCode().getText(arg);
+                                return createFixes(fixer, left, argText);
+                            },
+                        });
+                    }
+                    // Check for template literals like `${id}`
+                    if (left.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                        left.expressions.length === 1 &&
+                        left.quasis.length === 2 &&
+                        left.quasis[0].value.raw === '' &&
+                        left.quasis[1].value.raw === '') {
+                        context.report({
+                            node: left,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const expr = left.expressions[0];
+                                const exprText = context.getSourceCode().getText(expr);
+                                return createFixes(fixer, left, exprText);
+                            },
+                        });
+                    }
+                }
+            },
+            MemberExpression(node) {
+                if (node.computed) {
+                    const property = node.property;
+                    // Skip if already using assertSafe
+                    if (property.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        property.callee.name === 'assertSafe') {
+                        // Already using assertSafe, this is valid
+                        return;
+                    }
+                    // Try to determine if this is likely an array or dictionary
+                    const objectNode = node.object;
+                    let objectName = '';
+                    let isLikelyArray = false;
+                    if (objectNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        objectName = objectNode.name.toLowerCase();
+                        isLikelyArray =
+                            /^(array|arr|items|elements|list|collection|data)s?$/i.test(objectName);
+                    }
+                    // Check for string literals - allow them for dictionaries but not for regular objects
+                    if (property.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof property.value === 'string') {
+                        // String literals are fine, no need for assertSafe
+                        return;
+                    }
+                    // Check for numeric literals - always allow for arrays
+                    if (property.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof property.value === 'number') {
+                        // Numeric literals are fine, no need for assertSafe
+                        return;
+                    }
+                    // Check if we're using String(id) pattern
+                    if (property.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        property.callee.name === 'String') {
+                        context.report({
+                            node: property,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const arg = property.arguments[0];
+                                const argText = context.getSourceCode().getText(arg);
+                                return createFixes(fixer, property, argText);
+                            },
+                        });
+                        return;
+                    }
+                    // Check for template literals
+                    if (property.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                        // If it's a template literal in an array, allow it
+                        if (isLikelyArray) {
+                            return;
+                        }
+                        // Only flag simple template literals that are just `${id}`
+                        // Complex templates with additional text like `prefix_${id}_suffix` are allowed
+                        const isSimpleVarInterpolation = property.expressions.length === 1 &&
+                            property.quasis.length === 2 &&
+                            property.quasis[0].value.raw === '' &&
+                            property.quasis[1].value.raw === '';
+                        if (!isSimpleVarInterpolation) {
+                            // Complex template literals with additional text are fine
+                            return;
+                        }
+                        context.report({
+                            node: property,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                // Extract the expression from the template literal
+                                const expr = property.expressions[0];
+                                const exprText = context.getSourceCode().getText(expr);
+                                return createFixes(fixer, property, exprText);
+                            },
+                        });
+                        return;
+                    }
+                    // Check for direct variable usage (identifiers)
+                    if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // Skip numeric literals, they're safe
+                        if (/^\d+$/.test(property.name)) {
+                            return;
+                        }
+                        // If it looks like an array access, allow it
+                        if (isLikelyArray) {
+                            return;
+                        }
+                        context.report({
+                            node: property,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                // For direct variable use, just use the variable name
+                                const propText = context.getSourceCode().getText(property);
+                                return createFixes(fixer, property, propText);
+                            },
+                        });
+                        return;
+                    }
+                    // Check for binary expressions (like index + 1)
+                    if (property.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+                        // Allow binary expressions in array access
+                        if (isLikelyArray) {
+                            return;
+                        }
+                        context.report({
+                            node: property,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const propText = context.getSourceCode().getText(property);
+                                return createFixes(fixer, property, propText);
+                            },
+                        });
+                        return;
+                    }
+                    // Check for boolean expressions and other literals
+                    if (property.type === utils_1.AST_NODE_TYPES.Literal ||
+                        property.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                        property.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                        // Allow these expressions in array access
+                        if (isLikelyArray) {
+                            return;
+                        }
+                        context.report({
+                            node: property,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const propText = context.getSourceCode().getText(property);
+                                return createFixes(fixer, property, propText);
+                            },
+                        });
+                        return;
+                    }
+                    // Check for function calls (anything that isn't handled above)
+                    if (property.type === utils_1.AST_NODE_TYPES.MemberExpression ||
+                        (property.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                            !(property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                property.callee.name === 'String'))) {
+                        // Allow member expressions and function calls in array access
+                        if (isLikelyArray) {
+                            return;
+                        }
+                        context.report({
+                            node: property,
+                            messageId: 'useAssertSafe',
+                            fix(fixer) {
+                                const propText = context.getSourceCode().getText(property);
+                                return createFixes(fixer, property, propText);
+                            },
+                        });
+                        return;
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-assertSafe-object-key.js.map

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -21,34 +21,212 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         let hasCentralizedImport = false;
-        let mockFirestoreNodes = [];
+        const mockFirestoreNodes = new Set();
+        const customMockFirestoreNames = new Set();
+        const customMockFirestoreCallExpressions = new Set();
+        const thisExpressions = [];
         return {
             ImportDeclaration(node) {
                 if (node.source.value.endsWith(MOCK_FIRESTORE_PATH)) {
                     hasCentralizedImport = true;
+                    // Check for renamed imports
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.imported.name === 'mockFirestore' &&
+                            specifier.local.name !== 'mockFirestore') {
+                            customMockFirestoreNames.add(specifier.local.name);
+                        }
+                    }
                 }
             },
             VariableDeclarator(node) {
                 if (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.id.name === 'mockFirestore') {
-                    mockFirestoreNodes.push(node);
+                    mockFirestoreNodes.add(node);
+                }
+                else if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    for (const prop of node.id.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'mockFirestore') {
+                            mockFirestoreNodes.add(node);
+                            // Track renamed destructured imports
+                            if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                prop.value.name !== 'mockFirestore') {
+                                customMockFirestoreNames.add(prop.value.name);
+                            }
+                            break;
+                        }
+                    }
                 }
             },
-            'Program:exit'() {
-                if (!hasCentralizedImport && mockFirestoreNodes.length > 0) {
-                    for (const node of mockFirestoreNodes) {
-                        context.report({
-                            node,
-                            messageId: 'useCentralizedMockFirestore',
-                            fix(fixer) {
-                                const importFix = fixer.insertTextBefore(context.getSourceCode().ast.body[0], `import { mockFirestore } from '${MOCK_FIRESTORE_PATH}';\n\n`);
-                                const declarationFix = fixer.remove(node.parent);
-                                return [importFix, declarationFix];
-                            },
-                        });
+            PropertyDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === 'mockFirestore') {
+                    mockFirestoreNodes.add(node);
+                }
+            },
+            CallExpression(node) {
+                // Track calls to custom mockFirestore names
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    customMockFirestoreNames.has(node.callee.name)) {
+                    customMockFirestoreCallExpressions.add(node);
+                }
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'require' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.arguments[0].value === 'string' &&
+                    !node.arguments[0].value.endsWith(MOCK_FIRESTORE_PATH)) {
+                    const parent = node.parent;
+                    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                        for (const prop of parent.id.properties) {
+                            if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                prop.key.name === 'mockFirestore') {
+                                mockFirestoreNodes.add(parent);
+                                // Track renamed destructured imports
+                                if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                    prop.value.name !== 'mockFirestore') {
+                                    customMockFirestoreNames.add(prop.value.name);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            },
+            // Handle dynamic imports
+            'AwaitExpression > CallExpression[callee.type="ImportExpression"]'(node) {
+                const parent = node.parent;
+                if (parent?.type === utils_1.AST_NODE_TYPES.AwaitExpression &&
+                    parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    for (const prop of parent.parent.id.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'mockFirestore') {
+                            mockFirestoreNodes.add(parent.parent);
+                            // Track renamed destructured imports
+                            if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                prop.value.name !== 'mockFirestore') {
+                                customMockFirestoreNames.add(prop.value.name);
+                            }
+                            break;
+                        }
                     }
                 }
             },
+            // Handle complex object destructuring
+            'ObjectPattern > Property > ObjectPattern > Property > ObjectPattern > Property[key.name="mockFirestore"]'(node) {
+                let current = node;
+                while (current.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                        mockFirestoreNodes.add(current.parent);
+                        break;
+                    }
+                    current = current.parent;
+                }
+            },
+            // Capture this.mockFirestore expressions
+            MemberExpression(node) {
+                if (node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                    node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.property.name === 'mockFirestore') {
+                    thisExpressions.push(node);
+                }
+            },
+            'Program:exit'() {
+                if (mockFirestoreNodes.size > 0) {
+                    const sourceCode = context.getSourceCode();
+                    // Report only once for the entire file
+                    context.report({
+                        node: Array.from(mockFirestoreNodes)[0],
+                        messageId: 'useCentralizedMockFirestore',
+                        fix(fixer) {
+                            // Instead of trying to modify the code incrementally, we'll generate the entire fixed code
+                            const originalText = sourceCode.getText();
+                            const lines = originalText.split('\n');
+                            // Find the indentation of the code
+                            const indentMatch = lines[0].match(/^(\s*)/);
+                            const indent = indentMatch ? indentMatch[1] : '';
+                            // Create the import statement
+                            const importLine = `${indent}import { mockFirestore } from '${MOCK_FIRESTORE_PATH}';`;
+                            // Find all the lines that need to be removed
+                            const linesToRemove = new Set();
+                            // Process all nodes that need to be removed
+                            mockFirestoreNodes.forEach(node => {
+                                const startLine = sourceCode.getLocFromIndex(node.range[0]).line - 1;
+                                const endLine = sourceCode.getLocFromIndex(node.range[1]).line - 1;
+                                if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                                    // If it's the only declarator, remove the entire declaration
+                                    if (node.parent.declarations.length === 1) {
+                                        const declStartLine = sourceCode.getLocFromIndex(node.parent.range[0]).line - 1;
+                                        const declEndLine = sourceCode.getLocFromIndex(node.parent.range[1]).line - 1;
+                                        for (let i = declStartLine; i <= declEndLine; i++) {
+                                            linesToRemove.add(i);
+                                        }
+                                    }
+                                    else {
+                                        // Otherwise, just remove this declarator
+                                        for (let i = startLine; i <= endLine; i++) {
+                                            linesToRemove.add(i);
+                                        }
+                                    }
+                                }
+                                else if (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+                                    // Remove class property
+                                    for (let i = startLine; i <= endLine; i++) {
+                                        linesToRemove.add(i);
+                                    }
+                                }
+                            });
+                            // Replace custom mockFirestore references with the standard one
+                            const replacements = [];
+                            // Add replacements for custom mockFirestore names
+                            customMockFirestoreCallExpressions.forEach(node => {
+                                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    replacements.push([
+                                        node.callee.range[0],
+                                        node.callee.name,
+                                        'mockFirestore'
+                                    ]);
+                                }
+                            });
+                            // Add replacements for this.mockFirestore
+                            thisExpressions.forEach(expr => {
+                                replacements.push([
+                                    expr.range[0],
+                                    sourceCode.getText(expr),
+                                    'mockFirestore'
+                                ]);
+                            });
+                            // Sort replacements in reverse order to avoid range issues
+                            replacements.sort((a, b) => b[0] - a[0]);
+                            // Apply replacements to the original text
+                            let fixedText = originalText;
+                            for (const [pos, oldText, newText] of replacements) {
+                                fixedText =
+                                    fixedText.substring(0, pos) +
+                                        newText +
+                                        fixedText.substring(pos + oldText.length);
+                            }
+                            // Filter out the lines to remove
+                            const fixedLines = fixedText.split('\n').filter((_, i) => !linesToRemove.has(i));
+                            // Add the import statement at the beginning
+                            if (!hasCentralizedImport) {
+                                fixedLines.unshift(importLine);
+                            }
+                            // Join the lines back together
+                            const result = fixedLines.join('\n');
+                            // Return the fixed text
+                            return fixer.replaceText(sourceCode.ast, result);
+                        },
+                    });
+                }
+            },
         };
     },
 });

package/lib/rules/enforce-css-media-queries.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This rule enforces the use of CSS media queries instead of JavaScript-based breakpoints
+ * in React components for better performance and separation of concerns.
+ */
+export declare const enforceCssMediaQueries: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceCssMediaQueries", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-css-media-queries.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceCssMediaQueries = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * This rule enforces the use of CSS media queries instead of JavaScript-based breakpoints
+ * in React components for better performance and separation of concerns.
+ */
+exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
+    name: 'enforce-css-media-queries',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce CSS media queries over JS breakpoints',
+            recommended: 'error',
+        },
+        messages: {
+            enforceCssMediaQueries: 'Use CSS media queries instead of JavaScript breakpoints for responsive design. JavaScript breakpoint handling can cause unnecessary re-renders and impact performance.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // Check for Material-UI's useMediaQuery and react-responsive imports
+            ImportDeclaration(node) {
+                // Check for @mui/material useMediaQuery
+                if (node.source.value === '@mui/material' &&
+                    node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'useMediaQuery')) {
+                    context.report({
+                        node,
+                        messageId: 'enforceCssMediaQueries',
+                    });
+                }
+                // Check for react-responsive imports
+                if (node.source.value === 'react-responsive' ||
+                    node.source.value.includes('react-responsive/')) {
+                    context.report({
+                        node,
+                        messageId: 'enforceCssMediaQueries',
+                    });
+                }
+                // Check for useMobile import from hooks/useMobile
+                if (node.source.value.includes('hooks/useMobile') &&
+                    node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'useMobile')) {
+                    context.report({
+                        node,
+                        messageId: 'enforceCssMediaQueries',
+                    });
+                }
+            },
+            // Check for specific import specifiers
+            ImportSpecifier(node) {
+                if (node.parent &&
+                    node.parent.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                    node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (
+                    // Check for useMediaQuery from @mui/material
+                    (node.parent.source.value === '@mui/material' &&
+                        node.imported.name === 'useMediaQuery') ||
+                        // Check for useMobile from any source
+                        node.imported.name === 'useMobile')) {
+                    context.report({
+                        node,
+                        messageId: 'enforceCssMediaQueries',
+                    });
+                }
+            },
+            // Check for useMediaQuery and useMobile calls
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.callee.name === 'useMediaQuery' || node.callee.name === 'useMobile')) {
+                    context.report({
+                        node,
+                        messageId: 'enforceCssMediaQueries',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-css-media-queries.js.map

package/lib/rules/enforce-dynamic-imports.d.ts

@@ -0,0 +1,9 @@
+export declare const RULE_NAME = "enforce-dynamic-imports";
+type Options = [
+    {
+        libraries: string[];
+        allowImportType?: boolean;
+    }
+];
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"dynamicImportRequired", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;