@alexlit/lint-kit 167.2.0 → 167.4.0

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/eslint.d.ts

@@ -0,0 +1,216 @@
+import type { AST as JSONAST } from 'jsonc-eslint-parser';
+import type { AST as YAMLAST } from 'yaml-eslint-parser';
+import type { AST as VAST } from 'vue-eslint-parser';
+import type { JSONSchema4 } from 'json-schema';
+import type { VueParserServices } from './vue-parser-services';
+import type { TokenStore } from './types';
+import type { SettingsVueI18nLocaleDir } from './settings';
+import type { RuleListener } from './vue-parser-services';
+export interface Position {
+    line: number;
+    column: number;
+}
+export type Range = [number, number];
+export interface SourceLocation {
+    start: Position;
+    end: Position;
+}
+export interface MaybeNode {
+    type: string;
+    range: Range;
+    loc: SourceLocation;
+}
+export interface MaybeToken extends MaybeNode {
+    value: string;
+}
+export interface RuleContext {
+    id: string;
+    options: any[];
+    settings: {
+        'vue-i18n'?: {
+            localeDir?: SettingsVueI18nLocaleDir;
+            messageSyntaxVersion?: string;
+            cwd?: string;
+        };
+    };
+    parserPath: string;
+    report(descriptor: ReportDescriptor): void;
+    getCwd?: () => string;
+}
+interface ReportDescriptorOptionsBase {
+    data?: {
+        [key: string]: string;
+    };
+    fix?: null | ((fixer: RuleFixer) => null | Fix | IterableIterator<Fix> | Fix[]);
+}
+type SuggestionDescriptorMessage = {
+    desc: string;
+} | {
+    messageId: string;
+};
+export type SuggestionReportDescriptor = SuggestionDescriptorMessage & ReportDescriptorOptionsBase;
+interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
+    suggest?: SuggestionReportDescriptor[] | null;
+}
+type ReportDescriptor = ReportDescriptorMessage & ReportDescriptorLocation & ReportDescriptorOptions;
+type ReportDescriptorMessage = {
+    message: string;
+} | {
+    messageId: string;
+};
+type ReportDescriptorLocation = {
+    node: MaybeNode;
+} | {
+    loc: SourceLocation | {
+        line: number;
+        column: number;
+    };
+};
+export interface RuleFixer {
+    insertTextAfter(nodeOrToken: MaybeNode, text: string): Fix;
+    insertTextAfterRange(range: Range, text: string): Fix;
+    insertTextBefore(nodeOrToken: MaybeNode, text: string): Fix;
+    insertTextBeforeRange(range: Range, text: string): Fix;
+    remove(nodeOrToken: MaybeNode): Fix;
+    removeRange(range: Range): Fix;
+    replaceText(nodeOrToken: MaybeNode, text: string): Fix;
+    replaceTextRange(range: Range, text: string): Fix;
+}
+export interface Fix {
+    range: Range;
+    text: string;
+}
+export type FilterPredicate = (tokenOrComment: MaybeToken) => boolean;
+export type CursorWithSkipOptions = number | FilterPredicate | {
+    includeComments?: boolean;
+    filter?: FilterPredicate;
+    skip?: number;
+};
+export type CursorWithCountOptions = number | FilterPredicate | {
+    includeComments?: boolean;
+    filter?: FilterPredicate;
+    count?: number;
+};
+export interface SourceCode extends TokenStore {
+    text: string;
+    ast: VAST.ESLintProgram | JSONAST.JSONProgram | YAMLAST.YAMLProgram;
+    lines: string[];
+    hasBOM: boolean;
+    scopeManager: ScopeManager;
+    visitorKeys: VisitorKeys;
+    parserServices: {
+        isYAML?: true;
+        isJSON?: true;
+    } & VueParserServices;
+    getScope(node: MaybeNode): Scope;
+    getText(node?: MaybeNode, beforeCount?: number, afterCount?: number): string;
+    getLines(): string[];
+    getAllComments(): MaybeToken[];
+    getComments(node: MaybeNode): {
+        leading: MaybeToken[];
+        trailing: MaybeToken[];
+    };
+    getJSDocComment(node: MaybeNode): MaybeToken | null;
+    getNodeByRangeIndex(index: number): MaybeNode;
+    isSpaceBetweenTokens(first: MaybeToken, second: MaybeToken): boolean;
+    getLocFromIndex(index: number): Position;
+    getIndexFromLoc(location: Position): number;
+}
+export interface ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope | null;
+    acquire(node: VAST.ESLintNode | VAST.ESLintProgram, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: VAST.ESLintNode): Variable[];
+}
+export interface Scope {
+    type: 'block' | 'catch' | 'class' | 'for' | 'function' | 'function-expression-name' | 'global' | 'module' | 'switch' | 'with' | 'TDZ';
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: VAST.ESLintNode;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    functionExpressionScope: boolean;
+}
+export interface Variable {
+    name: string;
+    identifiers: VAST.ESLintIdentifier[];
+    references: Reference[];
+    defs: Definition[];
+}
+export interface Reference {
+    identifier: VAST.ESLintIdentifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: VAST.ESLintNode | null;
+    init: boolean;
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+}
+export type DefinitionType = {
+    type: 'CatchClause';
+    node: VAST.ESLintCatchClause;
+    parent: null;
+} | {
+    type: 'ClassName';
+    node: VAST.ESLintClassDeclaration | VAST.ESLintClassExpression;
+    parent: null;
+} | {
+    type: 'FunctionName';
+    node: VAST.ESLintFunctionDeclaration | VAST.ESLintFunctionExpression;
+    parent: null;
+} | {
+    type: 'ImplicitGlobalVariable';
+    node: VAST.ESLintProgram;
+    parent: null;
+} | {
+    type: 'ImportBinding';
+    node: VAST.ESLintImportSpecifier | VAST.ESLintImportDefaultSpecifier | VAST.ESLintImportNamespaceSpecifier;
+    parent: VAST.ESLintImportDeclaration;
+} | {
+    type: 'Parameter';
+    node: VAST.ESLintFunctionDeclaration | VAST.ESLintFunctionExpression | VAST.ESLintArrowFunctionExpression;
+    parent: null;
+} | {
+    type: 'TDZ';
+    node: any;
+    parent: null;
+} | {
+    type: 'Variable';
+    node: VAST.ESLintVariableDeclarator;
+    parent: VAST.ESLintVariableDeclaration;
+};
+export type Definition = DefinitionType & {
+    name: VAST.ESLintIdentifier;
+};
+export interface VisitorKeys {
+    [type: string]: string[];
+}
+export type RuleModule = {
+    create(context: RuleContext): RuleListener;
+    meta: RuleMetaData;
+};
+export interface RuleMetaData {
+    docs: {
+        description: string;
+        category: 'Recommended' | 'Best Practices' | 'Stylistic Issues';
+        recommended?: boolean;
+        replacedBy?: string[];
+        url: string;
+    };
+    messages?: {
+        [messageId: string]: string;
+    };
+    fixable: 'code' | 'whitespace' | null;
+    schema: JSONSchema4[];
+    hasSuggestions?: true;
+    deprecated?: boolean;
+    type: 'problem' | 'suggestion' | 'layout';
+}
+export {};

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/eslint.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/i18n.d.ts

@@ -0,0 +1,5 @@
+export type I18nLocaleMessageValue = string | null | undefined | number | boolean | symbol | bigint | I18nLocaleMessageDictionary;
+export type I18nLocaleMessageDictionary = {
+    [property: string]: I18nLocaleMessageValue;
+    [property: number]: I18nLocaleMessageValue;
+};

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/i18n.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './eslint';
+export * from './vue-parser-services';
+export * from './i18n';
+export * from './settings';
+export * from './nodes';

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./eslint"), exports);
+__exportStar(require("./vue-parser-services"), exports);
+__exportStar(require("./i18n"), exports);
+__exportStar(require("./settings"), exports);
+__exportStar(require("./nodes"), exports);

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/nodes.d.ts

@@ -0,0 +1,7 @@
+import type { MaybeNode } from './eslint';
+export interface JSXText extends MaybeNode {
+    type: 'JSXText';
+    value: string;
+    raw: string;
+    parent: MaybeNode;
+}

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/nodes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/settings.d.ts

@@ -0,0 +1,8 @@
+export type LocaleKeyType = 'file' | 'path' | 'key';
+export type SettingsVueI18nLocaleDir = SettingsVueI18nLocaleDirGlob | SettingsVueI18nLocaleDirObject | (SettingsVueI18nLocaleDirGlob | SettingsVueI18nLocaleDirObject)[];
+export type SettingsVueI18nLocaleDirGlob = string;
+export interface SettingsVueI18nLocaleDirObject {
+    pattern: string;
+    localeKey: LocaleKeyType;
+    localePattern?: string | RegExp;
+}

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/settings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/types.d.ts

@@ -0,0 +1,38 @@
+import type { MaybeToken, MaybeNode, CursorWithSkipOptions, CursorWithCountOptions } from './eslint';
+export interface TokenStore {
+    getTokenByRangeStart(offset: number, options?: {
+        includeComments: boolean;
+    }): MaybeToken | null;
+    getFirstToken(node: MaybeNode): MaybeToken;
+    getFirstToken(node: MaybeNode, options: number): MaybeToken;
+    getFirstToken(node: MaybeNode, options: CursorWithSkipOptions): MaybeToken | null;
+    getLastToken(node: MaybeNode): MaybeToken;
+    getLastToken(node: MaybeNode, options: number): MaybeToken;
+    getLastToken(node: MaybeNode, options: CursorWithSkipOptions): MaybeToken | null;
+    getTokenBefore(node: MaybeNode): MaybeToken;
+    getTokenBefore(node: MaybeNode, options: number): MaybeToken;
+    getTokenBefore(node: MaybeNode, options: {
+        includeComments: boolean;
+    }): MaybeToken;
+    getTokenBefore(node: MaybeNode, options: CursorWithSkipOptions): MaybeToken | null;
+    getTokenAfter(node: MaybeNode): MaybeToken;
+    getTokenAfter(node: MaybeNode, options: number): MaybeToken;
+    getTokenAfter(node: MaybeNode, options: {
+        includeComments: boolean;
+    }): MaybeToken;
+    getTokenAfter(node: MaybeNode, options: CursorWithSkipOptions): MaybeToken | null;
+    getFirstTokenBetween(left: MaybeNode, right: MaybeNode, options?: CursorWithSkipOptions): MaybeToken | null;
+    getLastTokenBetween(left: MaybeNode, right: MaybeNode, options?: CursorWithSkipOptions): MaybeToken | null;
+    getFirstTokens(node: MaybeNode, options?: CursorWithCountOptions): MaybeToken[];
+    getLastTokens(node: MaybeNode, options?: CursorWithCountOptions): MaybeToken[];
+    getTokensBefore(node: MaybeNode, options?: CursorWithCountOptions): MaybeToken[];
+    getTokensAfter(node: MaybeNode, options?: CursorWithCountOptions): MaybeToken[];
+    getFirstTokensBetween(left: MaybeNode, right: MaybeNode, options?: CursorWithCountOptions): MaybeToken[];
+    getLastTokensBetween(left: MaybeNode, right: MaybeNode, options?: CursorWithCountOptions): MaybeToken[];
+    getTokens(node: MaybeNode, beforeCount?: CursorWithCountOptions, afterCount?: number): MaybeToken[];
+    getTokensBetween(left: MaybeNode, right: MaybeNode, padding?: CursorWithCountOptions): MaybeToken[];
+    commentsExistBetween(left: MaybeNode, right: MaybeNode): boolean;
+    getCommentsBefore(nodeOrToken: MaybeNode): MaybeToken[];
+    getCommentsAfter(nodeOrToken: MaybeNode): MaybeToken[];
+    getCommentsInside(node: MaybeNode): MaybeToken[];
+}

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/vue-parser-services.d.ts

@@ -0,0 +1,32 @@
+import type { Rule } from 'eslint';
+import type { RuleContext, SourceCode } from './eslint';
+import type { AST as VAST } from 'vue-eslint-parser';
+import type { TokenStore } from './types';
+import type { VElement } from 'vue-eslint-parser/ast/index';
+export interface TemplateListener {
+    [key: string]: ((node: never) => void) | undefined;
+}
+export interface RuleListener {
+    onCodePathStart?(codePath: Rule.CodePath, node: never): void;
+    onCodePathEnd?(codePath: Rule.CodePath, node: never): void;
+    onCodePathSegmentStart?(segment: Rule.CodePathSegment, node: never): void;
+    onCodePathSegmentEnd?(segment: Rule.CodePathSegment, node: never): void;
+    onCodePathSegmentLoop?(fromSegment: Rule.CodePathSegment, toSegment: Rule.CodePathSegment, node: never): void;
+    [key: string]: ((node: never) => void) | ((codePath: Rule.CodePath, node: never) => void) | ((segment: Rule.CodePathSegment, node: never) => void) | ((fromSegment: Rule.CodePathSegment, toSegment: Rule.CodePathSegment, node: never) => void) | undefined;
+}
+export interface VueParserServices {
+    getTemplateBodyTokenStore: () => TokenStore;
+    defineTemplateBodyVisitor?: (templateBodyVisitor: TemplateListener, scriptVisitor?: RuleListener) => RuleListener;
+    defineCustomBlocksVisitor?: (context: RuleContext, parser: {
+        parseForESLint: (code: string, options: any) => any;
+    }, rule: {
+        target: string | string[] | ((lang: string | null, customBlock: VAST.VElement) => boolean);
+        create: CustomBlockVisitorFactory;
+    }, scriptVisitor?: RuleListener) => RuleListener;
+    getDocumentFragment?: () => VAST.VDocumentFragment | null;
+}
+export type CustomBlockVisitorFactory = (context: RuleContext & {
+    parserServices: SourceCode['parserServices'] & {
+        customBlock: VElement;
+    };
+}) => RuleListener;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/types/vue-parser-services.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/cache-function.d.ts

@@ -0,0 +1,2 @@
+import type { LoadData } from './cache-loader';
+export declare function defineCacheFunction<A extends any[], R>(fn: LoadData<A, R>): (...args: A) => R;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/cache-function.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineCacheFunction = void 0;
+const cache_loader_1 = require("./cache-loader");
+function defineCacheFunction(fn) {
+    const loader = new cache_loader_1.CacheLoader(fn, Infinity);
+    return (...args) => {
+        return loader.get(...args);
+    };
+}
+exports.defineCacheFunction = defineCacheFunction;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/cache-loader.d.ts

@@ -0,0 +1,10 @@
+export type LoadData<A extends any[], R> = (...args: A) => R;
+export declare class CacheLoader<A extends any[], R> {
+    private loader;
+    private timeout;
+    private _cacheTime;
+    private _cacheKey;
+    private _cache;
+    constructor(loader: LoadData<A, R>, timeout?: number | (() => number));
+    get(...args: A): R;
+}

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/cache-loader.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheLoader = void 0;
+const default_timeouts_1 = require("./default-timeouts");
+class CacheLoader {
+    constructor(loader, timeout = () => default_timeouts_1.CACHE_LOADER) {
+        this._cacheKey = null;
+        this._cache = null;
+        this.loader = loader;
+        this.timeout = timeout;
+        this._cacheTime = Number.MIN_SAFE_INTEGER;
+    }
+    get(...args) {
+        const key = JSON.stringify(args);
+        const now = Date.now();
+        if (this._cacheKey === key) {
+            const timeout = typeof this.timeout === 'function' ? this.timeout() : this.timeout;
+            if (this._cacheTime + timeout > now) {
+                return this._cache;
+            }
+        }
+        this._cacheKey = key;
+        this._cacheTime = now;
+        return (this._cache = this.loader(...args));
+    }
+}
+exports.CacheLoader = CacheLoader;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/casing.d.ts

@@ -0,0 +1,10 @@
+export declare function isKebabCase(str: string): boolean;
+export declare function isSnakeCase(str: string): boolean;
+export declare function isCamelCase(str: string): boolean;
+export declare function isLowerCase(str: string): boolean;
+export declare function isPascalCase(str: string): boolean;
+export declare function isScreamingSnakeCase(str: string): boolean;
+export declare function camelCase(str: string): string;
+export declare function pascalCase(str: string): string;
+export declare const allowedCaseOptions: readonly ["camelCase", "kebab-case", "lowercase", "PascalCase", "snake_case", "SCREAMING_SNAKE_CASE"];
+export declare function getCasingChecker(name: (typeof allowedCaseOptions)[number]): (str: string) => boolean;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/casing.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCasingChecker = exports.allowedCaseOptions = exports.pascalCase = exports.camelCase = exports.isScreamingSnakeCase = exports.isPascalCase = exports.isLowerCase = exports.isCamelCase = exports.isSnakeCase = exports.isKebabCase = void 0;
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function hasSymbols(str) {
+    return /[!"#%&'()*+,./:;<=>?@[\\\]^`{|}]/u.exec(str);
+}
+function hasUpper(str) {
+    return /[A-Z]/u.exec(str);
+}
+function hasLower(str) {
+    return /[a-z]/u.test(str);
+}
+function isKebabCase(str) {
+    if (hasUpper(str) ||
+        hasSymbols(str) ||
+        /^\d/u.exec(str) ||
+        /^-/u.exec(str) ||
+        /_|--|\s/u.exec(str)) {
+        return false;
+    }
+    return true;
+}
+exports.isKebabCase = isKebabCase;
+function isSnakeCase(str) {
+    if (hasUpper(str) ||
+        hasSymbols(str) ||
+        /^\d/u.exec(str) ||
+        /-|__|\s/u.exec(str)) {
+        return false;
+    }
+    return true;
+}
+exports.isSnakeCase = isSnakeCase;
+function isCamelCase(str) {
+    if (hasSymbols(str) ||
+        /^[A-Z\d]/u.exec(str) ||
+        /-|_|\s/u.exec(str)) {
+        return false;
+    }
+    return true;
+}
+exports.isCamelCase = isCamelCase;
+function isLowerCase(str) {
+    if (hasSymbols(str) ||
+        hasUpper(str) ||
+        /-|_|\s/u.exec(str)) {
+        return false;
+    }
+    return true;
+}
+exports.isLowerCase = isLowerCase;
+function isPascalCase(str) {
+    if (hasSymbols(str) ||
+        /^[a-z\d]/u.exec(str) ||
+        /-|_|\s/u.exec(str)) {
+        return false;
+    }
+    return true;
+}
+exports.isPascalCase = isPascalCase;
+function isScreamingSnakeCase(str) {
+    if (hasLower(str) || hasSymbols(str) || /-|__|\s/u.test(str)) {
+        return false;
+    }
+    return true;
+}
+exports.isScreamingSnakeCase = isScreamingSnakeCase;
+const checkersMap = {
+    'kebab-case': isKebabCase,
+    snake_case: isSnakeCase,
+    camelCase: isCamelCase,
+    lowercase: isLowerCase,
+    PascalCase: isPascalCase,
+    SCREAMING_SNAKE_CASE: isScreamingSnakeCase
+};
+function camelCase(str) {
+    if (isPascalCase(str)) {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+    return str.replace(/[-_](\w)/gu, (_, c) => (c ? c.toUpperCase() : ''));
+}
+exports.camelCase = camelCase;
+function pascalCase(str) {
+    return capitalize(camelCase(str));
+}
+exports.pascalCase = pascalCase;
+exports.allowedCaseOptions = [
+    'camelCase',
+    'kebab-case',
+    'lowercase',
+    'PascalCase',
+    'snake_case',
+    'SCREAMING_SNAKE_CASE'
+];
+function getCasingChecker(name) {
+    return checkersMap[name] || isPascalCase;
+}
+exports.getCasingChecker = getCasingChecker;

package/packages/config-eslint/node_modules/@intlify/eslint-plugin-vue-i18n/dist/utils/collect-keys.d.ts

@@ -0,0 +1,13 @@
+import { AST as VAST } from 'vue-eslint-parser';
+import { ResourceLoader } from './resource-loader';
+import type { RuleContext, VisitorKeys } from '../types';
+export declare function collectKeysFromAST(node: VAST.ESLintProgram, visitorKeys?: VisitorKeys): string[];
+declare class UsedKeysCache {
+    private _targetFilesLoader;
+    private _collectKeyResourcesFromFiles;
+    constructor();
+    collectKeysFromFiles(files: string[], extensions: string[], context: RuleContext): string[];
+    _getKeyResources(context: RuleContext, files: string[], extensions: string[]): ResourceLoader<string[]>[];
+}
+export declare const usedKeysCache: UsedKeysCache;
+export {};