@o3r/eslint-plugin 11.6.0-prerelease.6 → 11.6.0-prerelease.60

package/src/rules/typescript/matching-configuration-name/matching-configuration-name.js

@@ -10,8 +10,8 @@ exports.default = (0, utils_2.createRule)({
         fixable: 'code',
         type: 'problem',
         docs: {
-            // eslint-disable-next-line max-len
-            description: 'Ensures that the configuration interface name matches the first parameter of `computeItemIdentifier` (or `computeConfigurationName`) used beside the configuration interface to expose its ID (as generated by the configuration module).'
+            description: 'Ensures that the configuration interface name matches the first parameter of `computeItemIdentifier`'
+                + ' (or `computeConfigurationName`) used beside the configuration interface to expose its ID (as generated by the configuration module).'
         },
         schema: [],
         messages: {
@@ -21,49 +21,49 @@ exports.default = (0, utils_2.createRule)({
     },
     defaultOptions: [],
     create: (context) => {
-        return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            CallExpression: (node) => {
-                if (node.callee.type !== utils_1.TSESTree.AST_NODE_TYPES.Identifier
-                    || !nameDeterminingFunctionNames.includes(node.callee.name)
-                    || !node.arguments.length
-                    || node.arguments[0].type !== utils_1.TSESTree.AST_NODE_TYPES.Literal
-                    || typeof node.arguments[0].value !== 'string') {
-                    return;
-                }
-                const sourceCode = context.getSourceCode();
-                const interfaceNames = sourceCode.ast.body
-                    .filter((statement) => statement.type === utils_1.TSESTree.AST_NODE_TYPES.ExportNamedDeclaration
-                    && statement.declaration?.type === utils_1.TSESTree.AST_NODE_TYPES.TSInterfaceDeclaration
-                    && (statement.declaration.extends || []).some((heritageClause) => heritageClause.expression.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier
-                        && heritageClause.expression.name === 'Configuration'))
-                    .map((statement) => statement.declaration.id.name);
-                const fnArgInterfaceName = node.arguments[0].value;
-                if (interfaceNames.length && !interfaceNames.includes(fnArgInterfaceName)) {
-                    return context.report({
-                        node: node.arguments[0],
-                        loc: node.arguments[0].loc,
-                        messageId: 'error',
+        const rule = (node) => {
+            if (node.callee.type !== utils_1.TSESTree.AST_NODE_TYPES.Identifier
+                || !nameDeterminingFunctionNames.includes(node.callee.name)
+                || node.arguments.length === 0
+                || node.arguments[0].type !== utils_1.TSESTree.AST_NODE_TYPES.Literal
+                || typeof node.arguments[0].value !== 'string') {
+                return;
+            }
+            const { sourceCode } = context;
+            const interfaceNames = sourceCode.ast.body
+                .filter((statement) => statement.type === utils_1.TSESTree.AST_NODE_TYPES.ExportNamedDeclaration
+                && statement.declaration?.type === utils_1.TSESTree.AST_NODE_TYPES.TSInterfaceDeclaration
+                && (statement.declaration.extends || []).some((heritageClause) => heritageClause.expression.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier
+                    && heritageClause.expression.name === 'Configuration'))
+                .map((statement) => statement.declaration.id.name);
+            const fnArgInterfaceName = node.arguments[0].value;
+            if (interfaceNames.length > 0 && !interfaceNames.includes(fnArgInterfaceName)) {
+                return context.report({
+                    node: node.arguments[0],
+                    loc: node.arguments[0].loc,
+                    messageId: 'error',
+                    data: {
+                        currentValue: fnArgInterfaceName,
+                        possibleValues: interfaceNames.join(', ')
+                    },
+                    fix: (fixer) => {
+                        return fixer.replaceText(node.arguments[0], `'${interfaceNames[0]}'`);
+                    },
+                    suggest: interfaceNames.map((interfaceName) => ({
+                        messageId: 'suggestion',
                         data: {
                             currentValue: fnArgInterfaceName,
-                            possibleValues: interfaceNames.join(', ')
+                            recommendedValue: interfaceName
                         },
                         fix: (fixer) => {
-                            return fixer.replaceText(node.arguments[0], `'${interfaceNames[0]}'`);
-                        },
-                        suggest: interfaceNames.map((interfaceName) => ({
-                            messageId: 'suggestion',
-                            data: {
-                                currentValue: fnArgInterfaceName,
-                                recommendedValue: interfaceName
-                            },
-                            fix: (fixer) => {
-                                return fixer.replaceText(node.arguments[0], `'${interfaceName}'`);
-                            }
-                        }))
-                    });
-                }
+                            return fixer.replaceText(node.arguments[0], `'${interfaceName}'`);
+                        }
+                    }))
+                });
             }
         };
+        return {
+            CallExpression: rule
+        };
     }
 });

package/src/rules/typescript/no-folder-import-for-module/no-folder-import-for-module.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "indexFile", [], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "indexFile", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
 export default _default;

package/src/rules/typescript/no-folder-import-for-module/no-folder-import-for-module.js

@@ -20,30 +20,31 @@ exports.default = (0, utils_1.createRule)({
     },
     defaultOptions: [],
     create: (context) => {
-        return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            ImportDeclaration: (node) => {
-                const importedModules = node.specifiers.filter((specifier) => specifier.local.name.endsWith('Module'));
-                const importPath = node.source.value?.toString();
-                if (importedModules.length && importPath && importPath.startsWith('.') && !importPath.endsWith('.module') && !importPath.endsWith('index')) {
-                    const dirname = path.dirname(context.getFilename());
-                    const importTarget = path.resolve(dirname, importPath);
-                    if (!fs.existsSync(importTarget) || !fs.statSync(importTarget).isDirectory()) {
-                        return;
-                    }
-                    const indexPath = path.resolve(importTarget, 'index.ts');
-                    const indexFileExist = fs.existsSync(indexPath);
-                    const newIndexFilePath = path.join(importPath, 'index')
-                        .replace(/[\\/]/g, '/')
-                        .replace(/^([^.])/, './$1');
-                    context.report({
-                        node,
-                        messageId: 'error',
-                        fix: !indexFileExist ? undefined : (fixer) => {
+        const rule = (node) => {
+            const importedModules = node.specifiers.filter((specifier) => specifier.local.name.endsWith('Module'));
+            const importPath = node.source.value?.toString();
+            if (importedModules.length > 0 && importPath && importPath.startsWith('.') && !importPath.endsWith('.module') && !importPath.endsWith('index')) {
+                const dirname = path.dirname(context.filename);
+                const importTarget = path.resolve(dirname, importPath);
+                if (!fs.existsSync(importTarget) || !fs.statSync(importTarget).isDirectory()) {
+                    return;
+                }
+                const indexPath = path.resolve(importTarget, 'index.ts');
+                const indexFileExist = fs.existsSync(indexPath);
+                const newIndexFilePath = path.join(importPath, 'index')
+                    .replace(/[/\\]/g, '/')
+                    .replace(/^([^.])/, './$1');
+                context.report({
+                    node,
+                    messageId: 'error',
+                    fix: indexFileExist
+                        ? (fixer) => {
                             return fixer.replaceText(node.source, node.source.raw
                                 .replace(importPath, newIndexFilePath));
-                        },
-                        suggest: !indexFileExist ? undefined : [
+                        }
+                        : undefined,
+                    suggest: indexFileExist
+                        ? [
                             {
                                 messageId: 'indexFile',
                                 fix: (fixer) => {
@@ -55,9 +56,12 @@ exports.default = (0, utils_1.createRule)({
                                 }
                             }
                         ]
-                    });
-                }
+                        : undefined
+                });
             }
         };
+        return {
+            ImportDeclaration: rule
+        };
     }
 });

package/src/rules/typescript/no-multiple-type-configuration-property/no-multiple-type-configuration-property.d.ts

@@ -1,5 +1,5 @@
 export interface NoMultipleTypeConfigurationPropertyOption {
     supportedInterfaceNames?: string[];
 }
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"suggestion" | "error", [Required<NoMultipleTypeConfigurationPropertyOption>, ...any[]], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "suggestion", [Required<NoMultipleTypeConfigurationPropertyOption>, ...any[]], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
 export default _default;

package/src/rules/typescript/no-multiple-type-configuration-property/no-multiple-type-configuration-property.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const utils_2 = require("../../utils");
-const separatorRegExp = /\s*[|&]\s*/;
+const separatorRegExp = /\s*[&|]\s*/;
 exports.default = (0, utils_2.createRule)({
     name: 'no-multiple-type-configuration-property',
     meta: {
@@ -35,14 +35,14 @@ exports.default = (0, utils_2.createRule)({
         }],
     create: (context, [options]) => {
         const supportedInterfaceNames = options.supportedInterfaceNames;
-        const sourceCode = context.getSourceCode();
+        const { sourceCode } = context;
         const rule = (node) => {
             const interfaceDeclNode = node.parent?.parent?.parent?.parent;
             if (!(0, utils_2.isExtendingConfiguration)(interfaceDeclNode, supportedInterfaceNames)) {
                 return; // Not in a configuration interface
             }
             if (node.types.every((type) => type.type === utils_1.TSESTree.AST_NODE_TYPES.TSLiteralType && type.literal.type === utils_1.TSESTree.AST_NODE_TYPES.Literal)
-                && [...(new Set(node.types.map((literalType) => typeof literalType.literal.value)))].length === 1) {
+                && new Set(node.types.map((literalType) => typeof literalType.literal.value)).size === 1) {
                 return; // Only the same literal type
             }
             const text = sourceCode.getText(node);
@@ -61,9 +61,7 @@ exports.default = (0, utils_2.createRule)({
             });
         };
         return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
             TSUnionType: rule,
-            // eslint-disable-next-line @typescript-eslint/naming-convention
             TSIntersectionType: rule
         };
     }

package/src/rules/typescript/o3r-categories-tags/o3r-categories-tags.d.ts

@@ -3,5 +3,5 @@ export interface O3rCategoriesTagsRuleOption {
     globalConfigCategories?: string[];
 }
 type Messages = 'alreadyDefined' | 'undefinedCategory' | 'onlyOneCategoryAllowed' | 'notInConfigurationInterface' | 'suggestReplaceO3rCategory';
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<Messages, readonly [O3rCategoriesTagsRuleOption, ...any[]], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<Messages, readonly [O3rCategoriesTagsRuleOption, ...any[]], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
 export default _default;

package/src/rules/typescript/o3r-categories-tags/o3r-categories-tags.js

@@ -45,92 +45,92 @@ exports.default = (0, utils_1.createRule)({
         }],
     create: (context, [options]) => {
         const globalConfigCategories = new Set(options.globalConfigCategories);
-        return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            TSPropertySignature: (node) => {
-                const sourceCode = context.getSourceCode();
-                const comment = (0, utils_1.getNodeComment)(node, sourceCode);
-                if (!comment || !comment.value.length) {
-                    return;
-                }
-                const { loc, value: docText } = comment;
-                const categories = Array.from(docText.matchAll(/@o3rCategory (\w+)/g)).map((match) => match[1]);
-                if (categories.length < 1) {
-                    return;
-                }
-                else if (categories.length > 1) {
-                    return context.report({
-                        messageId: 'onlyOneCategoryAllowed',
-                        node,
-                        loc
-                    });
-                }
-                const category = categories[0];
-                const interfaceDeclNode = node.parent?.parent;
-                if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
-                    return context.report({
-                        messageId: 'notInConfigurationInterface',
-                        node,
-                        loc
-                    });
-                }
-                const interfaceComment = (0, utils_1.getNodeComment)(interfaceDeclNode, sourceCode);
-                const supportedO3rCategories = new Set(options.globalConfigCategories);
-                Array.from(interfaceComment?.value.matchAll(/@o3rCategories (\w+)/g) || []).forEach((match) => supportedO3rCategories.add(match[1]));
-                if (!supportedO3rCategories.has(category)) {
-                    return context.report({
-                        messageId: 'undefinedCategory',
-                        node,
-                        loc,
+        const ruleForProperties = (node) => {
+            const { sourceCode } = context;
+            const comment = (0, utils_1.getNodeComment)(node, sourceCode);
+            if (!comment || comment.value.length === 0) {
+                return;
+            }
+            const { loc, value: docText } = comment;
+            const categories = Array.from(docText.matchAll(/@o3rCategory (\w+)/g)).map((match) => match[1]);
+            if (categories.length === 0) {
+                return;
+            }
+            else if (categories.length > 1) {
+                return context.report({
+                    messageId: 'onlyOneCategoryAllowed',
+                    node,
+                    loc
+                });
+            }
+            const category = categories[0];
+            const interfaceDeclNode = node.parent?.parent;
+            if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
+                return context.report({
+                    messageId: 'notInConfigurationInterface',
+                    node,
+                    loc
+                });
+            }
+            const interfaceComment = (0, utils_1.getNodeComment)(interfaceDeclNode, sourceCode);
+            const supportedO3rCategories = new Set(options.globalConfigCategories);
+            Array.from(interfaceComment?.value.matchAll(/@o3rCategories (\w+)/g) || []).forEach((match) => supportedO3rCategories.add(match[1]));
+            if (!supportedO3rCategories.has(category)) {
+                return context.report({
+                    messageId: 'undefinedCategory',
+                    node,
+                    loc,
+                    data: {
+                        currentCategory: category,
+                        supportedCategories: Array.from(supportedO3rCategories).join(', ')
+                    },
+                    suggest: Array.from(supportedO3rCategories).map((suggestedCategory) => ({
+                        messageId: 'suggestReplaceO3rCategory',
                         data: {
                             currentCategory: category,
-                            supportedCategories: Array.from(supportedO3rCategories).join(', ')
+                            suggestedCategory
                         },
-                        suggest: Array.from(supportedO3rCategories).map((suggestedCategory) => ({
-                            messageId: 'suggestReplaceO3rCategory',
-                            data: {
-                                currentCategory: category,
-                                suggestedCategory: suggestedCategory
-                            },
-                            fix: (fixer) => {
-                                return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rCategory ${category}`, `@o3rCategory ${suggestedCategory}`)));
-                            }
-                        }))
-                    });
-                }
-            },
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            TSInterfaceDeclaration: (node) => {
-                const sourceCode = context.getSourceCode();
-                const comment = (0, utils_1.getNodeComment)(node, sourceCode);
-                if (!comment || !comment.value.length) {
-                    return;
-                }
-                const { loc, value: docText } = comment;
-                const categories = Array.from(docText.matchAll(/@o3rCategories (\w+)/g)).map((match) => match[1]);
-                if (categories.length < 1) {
-                    return;
-                }
-                if (!(0, utils_1.isExtendingConfiguration)(node, options.supportedInterfaceNames)) {
-                    return context.report({
-                        messageId: 'notInConfigurationInterface',
-                        node,
-                        loc
-                    });
-                }
-                const alreadyDefined = categories.find((category) => globalConfigCategories.has(category));
-                if (alreadyDefined) {
-                    return context.report({
-                        messageId: 'alreadyDefined',
-                        fix: (fixer) => fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(new RegExp(`.*@o3rCategories ${alreadyDefined}.*\n`), ''))),
-                        data: {
-                            currentCategory: alreadyDefined
-                        },
-                        node,
-                        loc
-                    });
-                }
+                        fix: (fixer) => {
+                            return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rCategory ${category}`, `@o3rCategory ${suggestedCategory}`)));
+                        }
+                    }))
+                });
+            }
+        };
+        const ruleForInterface = (node) => {
+            const { sourceCode } = context;
+            const comment = (0, utils_1.getNodeComment)(node, sourceCode);
+            if (!comment || comment.value.length === 0) {
+                return;
             }
+            const { loc, value: docText } = comment;
+            const categories = Array.from(docText.matchAll(/@o3rCategories (\w+)/g)).map((match) => match[1]);
+            if (categories.length === 0) {
+                return;
+            }
+            if (!(0, utils_1.isExtendingConfiguration)(node, options.supportedInterfaceNames)) {
+                return context.report({
+                    messageId: 'notInConfigurationInterface',
+                    node,
+                    loc
+                });
+            }
+            const alreadyDefined = categories.find((category) => globalConfigCategories.has(category));
+            if (alreadyDefined) {
+                return context.report({
+                    messageId: 'alreadyDefined',
+                    fix: (fixer) => fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(new RegExp(`.*@o3rCategories ${alreadyDefined}.*\n`), ''))),
+                    data: {
+                        currentCategory: alreadyDefined
+                    },
+                    node,
+                    loc
+                });
+            }
+        };
+        return {
+            TSPropertySignature: ruleForProperties,
+            TSInterfaceDeclaration: ruleForInterface
         };
     }
 });

package/src/rules/typescript/o3r-restriction-key-tags/o3r-restriction-key-tags.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export interface O3rRestrictionKeyTagsRuleOption {
+    supportedInterfaceNames?: string[];
+    supportedKeys?: string[];
+}
+type O3rWidgetRuleErrorId = 'notSupportedKey' | 'notWrapWithQuotes' | 'suggestWrapWithQuotes' | 'suggestUseSupportedKey' | 'noRestrictionKeyProvided' | 'notInConfigurationInterface';
+declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, [Readonly<O3rRestrictionKeyTagsRuleOption>, ...any[]], unknown, TSESLint.RuleListener>;
+export default _default;

package/src/rules/typescript/o3r-restriction-key-tags/o3r-restriction-key-tags.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const defaultOptions = [{
+        supportedInterfaceNames: utils_1.defaultSupportedInterfaceNames,
+        supportedKeys: []
+    }];
+exports.default = (0, utils_1.createRule)({
+    name: 'o3r-restriction-key-tags',
+    meta: {
+        hasSuggestions: true,
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            description: 'Ensures that @o3rRestrictionKey is used with a correct value'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    supportedInterfaceNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    supportedKeys: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        minItems: 1
+                    }
+                }
+            }
+        ],
+        messages: {
+            notSupportedKey: '{{ actualKey }} is not supported. Supported restriction keys: {{ supportedKeys }}.',
+            suggestUseSupportedKey: '{{ actualKey }} is not supported. Replace with {{ supportedKey }}.',
+            notWrapWithQuotes: '`{{ actualKey }}` is not wrapped with quotes.',
+            suggestWrapWithQuotes: 'Wrap `{{ actualKey }}` with quotes.',
+            notInConfigurationInterface: '@o3rRestrictionKey can only be used in a `Configuration` interface.',
+            noRestrictionKeyProvided: 'You must have at least one restriction key.'
+        }
+    },
+    defaultOptions,
+    create: (context, [options]) => {
+        const rule = (node) => {
+            const { sourceCode } = context;
+            const comment = (0, utils_1.getNodeComment)(node, sourceCode);
+            if (!comment || comment.value.length === 0) {
+                return;
+            }
+            const { loc, value: docText } = comment;
+            const supportedKeys = options.supportedKeys || defaultOptions[0].supportedKeys;
+            const supportedKeysSet = new Set(supportedKeys);
+            if (supportedKeys.length === 0) {
+                return context.report({
+                    messageId: 'noRestrictionKeyProvided',
+                    node,
+                    loc
+                });
+            }
+            const actualKeys = Array.from(docText.matchAll(/@o3rRestrictionKey\s+(.*)/g)).map((match) => match[1]);
+            if (actualKeys.length === 0) {
+                return;
+            }
+            const interfaceDeclNode = node.parent?.parent;
+            if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
+                return context.report({
+                    messageId: 'notInConfigurationInterface',
+                    node,
+                    loc
+                });
+            }
+            actualKeys.forEach((actualKey) => {
+                if (!supportedKeysSet.has(actualKey)) {
+                    if (/((["']).*?\2)/.test(actualKey)
+                        && supportedKeysSet.has(actualKey.replace(/(^["']|["']$)/g, ''))) {
+                        return;
+                    }
+                    const fix = (key) => (fixer) => {
+                        return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(actualKey, /[^\w]/.test(key) ? `"${key}"` : key)));
+                    };
+                    return context.report({
+                        messageId: 'notSupportedKey',
+                        node,
+                        loc,
+                        data: {
+                            actualKey,
+                            supportedKeys: supportedKeys.join(', ')
+                        },
+                        suggest: supportedKeys.map((supportedKey) => ({
+                            messageId: 'suggestUseSupportedKey',
+                            data: {
+                                actualKey,
+                                supportedKey
+                            },
+                            fix: fix(supportedKey)
+                        }))
+                    });
+                }
+                if (/[^\w]/.test(actualKey)) {
+                    const fix = (fixer) => {
+                        return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(actualKey, `"${actualKey}"`)));
+                    };
+                    return context.report({
+                        messageId: 'notWrapWithQuotes',
+                        data: {
+                            actualKey
+                        },
+                        node,
+                        loc,
+                        fix,
+                        suggest: [{
+                                messageId: 'suggestWrapWithQuotes',
+                                data: {
+                                    actualKey
+                                },
+                                fix
+                            }]
+                    });
+                }
+            });
+        };
+        return {
+            TSPropertySignature: rule
+        };
+    }
+});

package/src/rules/typescript/o3r-widget-tags/o3r-widget-tags.d.ts

@@ -12,5 +12,5 @@ export interface O3rWidgetTagsRuleOption {
     };
 }
 type O3rWidgetRuleErrorId = 'notInConfigurationInterface' | 'notSupportedType' | 'notSupportedParamForType' | 'invalidParamValueType' | 'noParamWithoutWidget' | 'onlyOneWidgetAllowed' | 'duplicatedParam' | 'requiredParamMissing' | 'suggestParamMissing' | 'suggestRemoveDuplicatedO3rWidget' | 'suggestRemoveDuplicatedO3rWidgetParam' | 'suggestAddO3rWidgetTag' | 'suggestReplaceO3rWidgetType';
-declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, [Readonly<O3rWidgetTagsRuleOption>, ...any[]], TSESLint.RuleListener>;
+declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, [Readonly<O3rWidgetTagsRuleOption>, ...any[]], unknown, TSESLint.RuleListener>;
 export default _default;