@stride.it/appoint-lint-governance 0.1.21 → 0.1.23

package/dist/index.d.ts

@@ -1,20 +1,1253 @@
-import * as typescript_eslint from 'typescript-eslint';
+import * as eslint from 'eslint';
 import { ESLint } from 'eslint';
+import { JSONSchema4 } from 'json-schema';
+import * as eslint_plugin_regexp from 'eslint-plugin-regexp';
+import * as typescript_eslint from 'typescript-eslint';
+import * as _eslint_core from '@eslint/core';
+import * as comments from '@eslint-community/eslint-plugin-eslint-comments';
+import * as eslint_plugin_jsdoc from 'eslint-plugin-jsdoc';
 
-interface TypescriptBaseOptions {
-    files?: string[];
+interface CompatibleParser {
+    parseForESLint(text: string): {
+        ast: unknown;
+        scopeManager: unknown;
+    };
+}
+interface CompatiblePlugin {
+    meta: {
+        name: string;
+    };
 }
-declare function typescriptBase(options?: TypescriptBaseOptions): typescript_eslint.FlatConfig.ConfigArray;
 
-interface TypescriptConventionsOptions {
+type TypescriptBaseOptions = {
     files?: string[];
+};
+declare function typescriptBase(options?: TypescriptBaseOptions): {
+    files: string[];
+    plugins: {
+        "@typescript-eslint": CompatiblePlugin;
+    };
+    languageOptions: {
+        parser: CompatibleParser;
+        parserOptions: {
+            ecmaVersion: string;
+            sourceType: string;
+        };
+    };
+    rules: {
+        "@typescript-eslint/consistent-type-imports": string;
+        "@typescript-eslint/no-unused-vars": string;
+        "@typescript-eslint/no-shadow": string;
+        "@typescript-eslint/ban-ts-comment": string;
+        "@typescript-eslint/no-explicit-any": string;
+        "@typescript-eslint/no-inferrable-types": string;
+        "no-undef": string;
+        "no-unused-vars": string;
+        "no-var": string;
+        "prefer-const": string;
+        eqeqeq: (string | {
+            null: string;
+        })[];
+        "no-implicit-coercion": string;
+    };
+}[];
+
+/**
+ * @fileoverview Shared types for ESLint Core.
+ */
+
+/**
+ * Represents an error inside of a file.
+ */
+interface FileError {
+    message: string;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+}
+/**
+ * Represents a problem found in a file.
+ */
+interface FileProblem {
+    ruleId: string | null;
+    message: string;
+    loc: SourceLocation;
+}
+/**
+ * Represents the start and end coordinates of a node inside the source.
+ */
+interface SourceLocation {
+    start: Position;
+    end: Position;
+}
+/**
+ * Represents a location coordinate inside the source. ESLint-style formats
+ * have just `line` and `column` while others may have `offset` as well.
+ */
+interface Position {
+    line: number;
+    column: number;
+}
+/**
+ * Represents a range of characters in the source.
+ */
+type SourceRange = [number, number];
+/**
+ * What the rule is responsible for finding:
+ * - `problem` means the rule has noticed a potential error.
+ * - `suggestion` means the rule suggests an alternate or better approach.
+ * - `layout` means the rule is looking at spacing, indentation, etc.
+ */
+type RuleType = "problem" | "suggestion" | "layout";
+/**
+ * The type of fix the rule can provide:
+ * - `code` means the rule can fix syntax.
+ * - `whitespace` means the rule can fix spacing and indentation.
+ */
+type RuleFixType = "code" | "whitespace";
+/**
+ * An object containing visitor information for a rule. Each method is either the
+ * name of a node type or a selector, or is a method that will be called at specific
+ * times during the traversal.
+ */
+type RuleVisitor = Record<string, ((...args: any[]) => void) | undefined>;
+/**
+ * Rule meta information used for documentation.
+ */
+interface RulesMetaDocs {
+    /**
+     * A short description of the rule.
+     */
+    description?: string | undefined;
+    /**
+     * The URL to the documentation for the rule.
+     */
+    url?: string | undefined;
+    /**
+     * The category the rule falls under.
+     * @deprecated No longer used.
+     */
+    category?: string | undefined;
+    /**
+     * Indicates if the rule is generally recommended for all users.
+     *
+     * Note - this will always be a boolean for core rules, but may be used in any way by plugins.
+     */
+    recommended?: unknown;
+    /**
+     * Indicates if the rule is frozen (no longer accepting feature requests).
+     */
+    frozen?: boolean | undefined;
+}
+/**
+ * Meta information about a rule.
+ */
+interface RulesMeta<MessageIds extends string = string, RuleOptions = unknown[], ExtRuleDocs = unknown> {
+    /**
+     * Properties that are used when documenting the rule.
+     */
+    docs?: (RulesMetaDocs & ExtRuleDocs) | undefined;
+    /**
+     * The type of rule.
+     */
+    type?: RuleType | undefined;
+    /**
+     * The schema for the rule options. Required if the rule has options.
+     */
+    schema?: JSONSchema4 | JSONSchema4[] | false | undefined;
+    /**
+     * Any default options to be recursively merged on top of any user-provided options.
+     */
+    defaultOptions?: RuleOptions;
+    /**
+     * The messages that the rule can report.
+     */
+    messages?: Record<MessageIds, string>;
+    /**
+     * Indicates whether the rule has been deprecated or provides additional metadata about the deprecation. Omit if not deprecated.
+     */
+    deprecated?: boolean | DeprecatedInfo | undefined;
+    /**
+     * @deprecated Use deprecated.replacedBy instead.
+     * The name of the rule(s) this rule was replaced by, if it was deprecated.
+     */
+    replacedBy?: readonly string[] | undefined;
+    /**
+     * Indicates if the rule is fixable, and if so, what type of fix it provides.
+     */
+    fixable?: RuleFixType | undefined;
+    /**
+     * Indicates if the rule may provide suggestions.
+     */
+    hasSuggestions?: boolean | undefined;
+    /**
+     * The language the rule is intended to lint.
+     */
+    language?: string;
+    /**
+     * The dialects of `language` that the rule is intended to lint.
+     */
+    dialects?: string[];
+}
+/**
+ * Provides additional metadata about a deprecation.
+ */
+interface DeprecatedInfo {
+    /**
+     * General message presented to the user, e.g. for the key rule why the rule
+     * is deprecated or for info how to replace the rule.
+     */
+    message?: string;
+    /**
+     * URL to more information about this deprecation in general.
+     */
+    url?: string;
+    /**
+     * An empty array explicitly states that there is no replacement.
+     */
+    replacedBy?: ReplacedByInfo[];
+    /**
+     * The package version since when the rule is deprecated (should use full
+     * semver without a leading "v").
+     */
+    deprecatedSince?: string;
+    /**
+     * The estimated version when the rule is removed (probably the next major
+     * version). null means the rule is "frozen" (will be available but will not
+     * be changed).
+     */
+    availableUntil?: string | null;
+}
+/**
+ * Provides metadata about a replacement
+ */
+interface ReplacedByInfo {
+    /**
+     * General message presented to the user, e.g. how to replace the rule
+     */
+    message?: string;
+    /**
+     * URL to more information about this replacement in general
+     */
+    url?: string;
+    /**
+     * Name should be "eslint" if the replacement is an ESLint core rule. Omit
+     * the property if the replacement is in the same plugin.
+     */
+    plugin?: ExternalSpecifier;
+    /**
+     * Name and documentation of the replacement rule
+     */
+    rule?: ExternalSpecifier;
+}
+/**
+ * Specifies the name and url of an external resource. At least one property
+ * should be set.
+ */
+interface ExternalSpecifier {
+    /**
+     * Name of the referenced plugin / rule.
+     */
+    name?: string;
+    /**
+     * URL pointing to documentation for the plugin / rule.
+     */
+    url?: string;
+}
+/**
+ * Generic type for `RuleContext`.
+ */
+interface RuleContextTypeOptions {
+    LangOptions: LanguageOptions;
+    Code: SourceCode;
+    RuleOptions: unknown[];
+    Node: unknown;
+    MessageIds: string;
+}
+/**
+ * Represents the context object that is passed to a rule. This object contains
+ * information about the current state of the linting process and is the rule's
+ * view into the outside world.
+ */
+interface RuleContext<Options extends RuleContextTypeOptions = RuleContextTypeOptions> {
+    /**
+     * The current working directory for the session.
+     */
+    cwd: string;
+    /**
+     * Returns the current working directory for the session.
+     * @deprecated Use `cwd` instead.
+     */
+    getCwd(): string;
+    /**
+     * The filename of the file being linted.
+     */
+    filename: string;
+    /**
+     * Returns the filename of the file being linted.
+     * @deprecated Use `filename` instead.
+     */
+    getFilename(): string;
+    /**
+     * The physical filename of the file being linted.
+     */
+    physicalFilename: string;
+    /**
+     * Returns the physical filename of the file being linted.
+     * @deprecated Use `physicalFilename` instead.
+     */
+    getPhysicalFilename(): string;
+    /**
+     * The source code object that the rule is running on.
+     */
+    sourceCode: Options["Code"];
+    /**
+     * Returns the source code object that the rule is running on.
+     * @deprecated Use `sourceCode` instead.
+     */
+    getSourceCode(): Options["Code"];
+    /**
+     * Shared settings for the configuration.
+     */
+    settings: SettingsConfig;
+    /**
+     * Parser-specific options for the configuration.
+     * @deprecated Use `languageOptions.parserOptions` instead.
+     */
+    parserOptions: Record<string, unknown>;
+    /**
+     * The language options for the configuration.
+     */
+    languageOptions: Options["LangOptions"];
+    /**
+     * The CommonJS path to the parser used while parsing this file.
+     * @deprecated No longer used.
+     */
+    parserPath: string | undefined;
+    /**
+     * The rule ID.
+     */
+    id: string;
+    /**
+     * The rule's configured options.
+     */
+    options: Options["RuleOptions"];
+    /**
+     * The report function that the rule should use to report problems.
+     * @param violation The violation to report.
+     */
+    report(violation: ViolationReport<Options["Node"], Options["MessageIds"]>): void;
+}
+/**
+ * Manager of text edits for a rule fix.
+ */
+interface RuleTextEditor<EditableSyntaxElement = unknown> {
+    /**
+     * Inserts text after the specified node or token.
+     * @param syntaxElement The node or token to insert after.
+     * @param text The edit to insert after the node or token.
+     */
+    insertTextAfter(syntaxElement: EditableSyntaxElement, text: string): RuleTextEdit;
+    /**
+     * Inserts text after the specified range.
+     * @param range The range to insert after.
+     * @param text The edit to insert after the range.
+     */
+    insertTextAfterRange(range: SourceRange, text: string): RuleTextEdit;
+    /**
+     * Inserts text before the specified node or token.
+     * @param syntaxElement A syntax element with location information to insert before.
+     * @param text The edit to insert before the node or token.
+     */
+    insertTextBefore(syntaxElement: EditableSyntaxElement, text: string): RuleTextEdit;
+    /**
+     * Inserts text before the specified range.
+     * @param range The range to insert before.
+     * @param text The edit to insert before the range.
+     */
+    insertTextBeforeRange(range: SourceRange, text: string): RuleTextEdit;
+    /**
+     * Removes the specified node or token.
+     * @param syntaxElement A syntax element with location information to remove.
+     * @returns The edit to remove the node or token.
+     */
+    remove(syntaxElement: EditableSyntaxElement): RuleTextEdit;
+    /**
+     * Removes the specified range.
+     * @param range The range to remove.
+     * @returns The edit to remove the range.
+     */
+    removeRange(range: SourceRange): RuleTextEdit;
+    /**
+     * Replaces the specified node or token with the given text.
+     * @param syntaxElement A syntax element with location information to replace.
+     * @param text The text to replace the node or token with.
+     * @returns The edit to replace the node or token.
+     */
+    replaceText(syntaxElement: EditableSyntaxElement, text: string): RuleTextEdit;
+    /**
+     * Replaces the specified range with the given text.
+     * @param range The range to replace.
+     * @param text The text to replace the range with.
+     * @returns The edit to replace the range.
+     */
+    replaceTextRange(range: SourceRange, text: string): RuleTextEdit;
+}
+/**
+ * Represents a fix for a rule violation implemented as a text edit.
+ */
+interface RuleTextEdit {
+    /**
+     * The range to replace.
+     */
+    range: SourceRange;
+    /**
+     * The text to insert.
+     */
+    text: string;
+}
+/**
+ * Fixes a violation.
+ * @param fixer The text editor to apply the fix.
+ * @returns The fix(es) for the violation.
+ */
+type RuleFixer = (fixer: RuleTextEditor) => RuleTextEdit | Iterable<RuleTextEdit> | null;
+interface ViolationReportBase {
+    /**
+     * The data to insert into the message.
+     */
+    data?: Record<string, unknown> | undefined;
+    /**
+     * The fix to be applied for the violation.
+     */
+    fix?: RuleFixer | null | undefined;
+    /**
+     * An array of suggested fixes for the problem. These fixes may change the
+     * behavior of the code, so they are not applied automatically.
+     */
+    suggest?: SuggestedEdit[] | null | undefined;
+}
+type ViolationMessage<MessageIds = string> = {
+    message: string;
+} | {
+    messageId: MessageIds;
+};
+type ViolationLocation<Node> = {
+    loc: SourceLocation | Position;
+} | {
+    node: Node;
+};
+type ViolationReport<Node = unknown, MessageIds = string> = ViolationReportBase & ViolationMessage<MessageIds> & ViolationLocation<Node>;
+interface SuggestedEditBase {
+    /**
+     * The data to insert into the message.
+     */
+    data?: Record<string, unknown> | undefined;
+    /**
+     * The fix to be applied for the suggestion.
+     */
+    fix: RuleFixer;
+}
+type SuggestionMessage = {
+    desc: string;
+} | {
+    messageId: string;
+};
+/**
+ * A suggested edit for a rule violation.
+ */
+type SuggestedEdit = SuggestedEditBase & SuggestionMessage;
+/**
+ * The normalized version of a lint suggestion.
+ */
+interface LintSuggestion {
+    /** A short description. */
+    desc: string;
+    /** Fix result info. */
+    fix: RuleTextEdit;
+    /** Id referencing a message for the description. */
+    messageId?: string | undefined;
+}
+/**
+ * The normalized version of a lint violation message.
+ */
+interface LintMessage {
+    /** The 1-based column number. */
+    column: number;
+    /** The 1-based line number. */
+    line: number;
+    /** The 1-based column number of the end location. */
+    endColumn?: number | undefined;
+    /** The 1-based line number of the end location. */
+    endLine?: number | undefined;
+    /** The ID of the rule which makes this message. */
+    ruleId: string | null;
+    /** The reported message. */
+    message: string;
+    /** The ID of the message in the rule's meta. */
+    messageId?: string | undefined;
+    /**
+     * Type of node.
+     * @deprecated `nodeType` is deprecated and will be removed in the next major version.
+     */
+    nodeType?: string | undefined;
+    /** If `true` then this is a fatal error. */
+    fatal?: true | undefined;
+    /** The severity of this message. */
+    severity: Exclude<SeverityLevel, 0>;
+    /** Information for autofix. */
+    fix?: RuleTextEdit | undefined;
+    /** Information for suggestions. */
+    suggestions?: LintSuggestion[] | undefined;
+}
+/**
+ * Generic options for the `RuleDefinition` type.
+ */
+interface RuleDefinitionTypeOptions {
+    LangOptions: LanguageOptions;
+    Code: SourceCode;
+    RuleOptions: unknown[];
+    Visitor: RuleVisitor;
+    Node: unknown;
+    MessageIds: string;
+    ExtRuleDocs: unknown;
+}
+/**
+ * The definition of an ESLint rule.
+ */
+interface RuleDefinition<Options extends RuleDefinitionTypeOptions = RuleDefinitionTypeOptions> {
+    /**
+     * The meta information for the rule.
+     */
+    meta?: RulesMeta<Options["MessageIds"], Options["RuleOptions"], Options["ExtRuleDocs"]>;
+    /**
+     * Creates the visitor that ESLint uses to apply the rule during traversal.
+     * @param context The rule context.
+     * @returns The rule visitor.
+     */
+    create(context: RuleContext<{
+        LangOptions: Options["LangOptions"];
+        Code: Options["Code"];
+        RuleOptions: Options["RuleOptions"];
+        Node: Options["Node"];
+        MessageIds: Options["MessageIds"];
+    }>): Options["Visitor"];
+}
+/**
+ * The human readable severity level used in a configuration.
+ */
+type SeverityName = "off" | "warn" | "error";
+/**
+ * The numeric severity level for a rule.
+ *
+ * - `0` means off.
+ * - `1` means warn.
+ * - `2` means error.
+ */
+type SeverityLevel = 0 | 1 | 2;
+/**
+ * The severity of a rule in a configuration.
+ */
+type Severity = SeverityName | SeverityLevel;
+/**
+ * Represents the metadata for an object, such as a plugin or processor.
+ */
+interface ObjectMetaProperties {
+    /** @deprecated Use `meta.name` instead. */
+    name?: string | undefined;
+    /** @deprecated Use `meta.version` instead. */
+    version?: string | undefined;
+    meta?: {
+        name?: string | undefined;
+        version?: string | undefined;
+    };
+}
+/**
+ * Represents the configuration options for the core linter.
+ */
+interface LinterOptionsConfig {
+    /**
+     * Indicates whether or not inline configuration is evaluated.
+     */
+    noInlineConfig?: boolean;
+    /**
+     * Indicates what to do when an unused disable directive is found.
+     */
+    reportUnusedDisableDirectives?: boolean | Severity;
+    /**
+     * A severity value indicating if and how unused inline configs should be
+     * tracked and reported.
+     */
+    reportUnusedInlineConfigs?: Severity;
+}
+/**
+ * The configuration for a rule.
+ */
+type RuleConfig<RuleOptions extends unknown[] = unknown[]> = Severity | [Severity, ...Partial<RuleOptions>];
+/**
+ * A collection of rules and their configurations.
+ */
+interface RulesConfig {
+    [key: string]: RuleConfig;
+}
+/**
+ * A collection of settings.
+ */
+interface SettingsConfig {
+    [key: string]: unknown;
+}
+/**
+ * The configuration for a set of files.
+ */
+interface ConfigObject<Rules extends RulesConfig = RulesConfig> {
+    /**
+     * A string to identify the configuration object. Used in error messages and
+     * inspection tools.
+     */
+    name?: string;
+    /**
+     * Path to the directory where the configuration object should apply.
+     * `files` and `ignores` patterns in the configuration object are
+     * interpreted as relative to this path.
+     */
+    basePath?: string;
+    /**
+     * An array of glob patterns indicating the files that the configuration
+     * object should apply to. If not specified, the configuration object applies
+     * to all files
+     */
+    files?: (string | string[])[];
+    /**
+     * An array of glob patterns indicating the files that the configuration
+     * object should not apply to. If not specified, the configuration object
+     * applies to all files matched by files
+     */
+    ignores?: string[];
+    /**
+     * The name of the language used for linting. This is used to determine the
+     * parser and other language-specific settings.
+     * @since 9.7.0
+     */
+    language?: string;
+    /**
+     * An object containing settings related to how the language is configured for
+     * linting.
+     */
+    languageOptions?: LanguageOptions;
+    /**
+     * An object containing settings related to the linting process
+     */
+    linterOptions?: LinterOptionsConfig;
+    /**
+     * Either an object containing preprocess() and postprocess() methods or a
+     * string indicating the name of a processor inside of a plugin
+     * (i.e., "pluginName/processorName").
+     */
+    processor?: string | Processor;
+    /**
+     * An object containing a name-value mapping of plugin names to plugin objects.
+     * When files is specified, these plugins are only available to the matching files.
+     */
+    plugins?: Record<string, Plugin>;
+    /**
+     * An object containing the configured rules. When files or ignores are specified,
+     * these rule configurations are only available to the matching files.
+     */
+    rules?: Partial<Rules>;
+    /**
+     * An object containing name-value pairs of information that should be
+     * available to all rules.
+     */
+    settings?: Record<string, unknown>;
+}
+/** @deprecated Only supported in legacy eslintrc config format. */
+type GlobalAccess = boolean | "off" | "readable" | "readonly" | "writable" | "writeable";
+/** @deprecated Only supported in legacy eslintrc config format. */
+interface GlobalsConfig {
+    [name: string]: GlobalAccess;
+}
+/**
+ * The ECMAScript version of the code being linted.
+ * @deprecated Only supported in legacy eslintrc config format.
+ */
+type EcmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | "latest";
+/**
+ * The type of JavaScript source code.
+ * @deprecated Only supported in legacy eslintrc config format.
+ */
+type JavaScriptSourceType = "script" | "module" | "commonjs";
+/**
+ * Parser options.
+ * @deprecated Only supported in legacy eslintrc config format.
+ * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)
+ */
+interface JavaScriptParserOptionsConfig {
+    /**
+     * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3).
+     *
+     * @default false
+     */
+    allowReserved?: boolean | undefined;
+    /**
+     * Accepts any valid ECMAScript version number or `'latest'`:
+     *
+     * - A version: es3, es5, es6, es7, es8, es9, es10, es11, es12, es13, es14, ..., or
+     * - A year: es2015, es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, ..., or
+     * - `'latest'`
+     *
+     * When it's a version or a year, the value must be a number - so do not include the `es` prefix.
+     *
+     * Specifies the version of ECMAScript syntax you want to use. This is used by the parser to determine how to perform scope analysis, and it affects the default
+     *
+     * @default 5
+     */
+    ecmaVersion?: EcmaVersion | undefined;
+    /**
+     * The type of JavaScript source code. Possible values are "script" for
+     * traditional script files, "module" for ECMAScript modules (ESM), and
+     * "commonjs" for CommonJS files.
+     *
+     * @default 'script'
+     *
+     * @see https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options
+     */
+    sourceType?: JavaScriptSourceType | undefined;
+    /**
+     * An object indicating which additional language features you'd like to use.
+     *
+     * @see https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options
+     */
+    ecmaFeatures?: {
+        globalReturn?: boolean | undefined;
+        impliedStrict?: boolean | undefined;
+        jsx?: boolean | undefined;
+        experimentalObjectRestSpread?: boolean | undefined;
+        [key: string]: any;
+    } | undefined;
+    [key: string]: any;
+}
+/** @deprecated Only supported in legacy eslintrc config format. */
+interface EnvironmentConfig {
+    /** The definition of global variables. */
+    globals?: GlobalsConfig | undefined;
+    /** The parser options that will be enabled under this environment. */
+    parserOptions?: JavaScriptParserOptionsConfig | undefined;
+}
+/**
+ * A configuration object that may have a `rules` block.
+ */
+interface HasRules<Rules extends RulesConfig = RulesConfig> {
+    rules?: Partial<Rules> | undefined;
+}
+/**
+ * ESLint legacy configuration.
+ *
+ * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+ */
+interface BaseConfig<Rules extends RulesConfig = RulesConfig, OverrideRules extends RulesConfig = Rules> extends HasRules<Rules> {
+    $schema?: string | undefined;
+    /**
+     * An environment provides predefined global variables.
+     *
+     * @see [Environments](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-environments)
+     */
+    env?: {
+        [name: string]: boolean;
+    } | undefined;
+    /**
+     * Extending configuration files.
+     *
+     * @see [Extends](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#extending-configuration-files)
+     */
+    extends?: string | string[] | undefined;
+    /**
+     * Specifying globals.
+     *
+     * @see [Globals](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-globals)
+     */
+    globals?: GlobalsConfig | undefined;
+    /**
+     * Disable processing of inline comments.
+     *
+     * @see [Disabling Inline Comments](https://eslint.org/docs/latest/use/configure/rules-deprecated#disabling-inline-comments)
+     */
+    noInlineConfig?: boolean | undefined;
+    /**
+     * Overrides can be used to use a differing configuration for matching sub-directories and files.
+     *
+     * @see [How do overrides work](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#how-do-overrides-work)
+     */
+    overrides?: ConfigOverride<OverrideRules>[] | undefined;
+    /**
+     * Parser.
+     *
+     * @see [Working with Custom Parsers](https://eslint.org/docs/latest/extend/custom-parsers)
+     * @see [Specifying Parser](https://eslint.org/docs/latest/use/configure/parser-deprecated)
+     */
+    parser?: string | undefined;
+    /**
+     * Parser options.
+     *
+     * @see [Working with Custom Parsers](https://eslint.org/docs/latest/extend/custom-parsers)
+     * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options)
+     */
+    parserOptions?: JavaScriptParserOptionsConfig | undefined;
+    /**
+     * Which third-party plugins define additional rules, environments, configs, etc. for ESLint to use.
+     *
+     * @see [Configuring Plugins](https://eslint.org/docs/latest/use/configure/plugins-deprecated#configure-plugins)
+     */
+    plugins?: string[] | undefined;
+    /**
+     * Specifying processor.
+     *
+     * @see [processor](https://eslint.org/docs/latest/use/configure/plugins-deprecated#specify-a-processor)
+     */
+    processor?: string | undefined;
+    /**
+     * Report unused eslint-disable comments as warning.
+     *
+     * @see [Report unused eslint-disable comments](https://eslint.org/docs/latest/use/configure/rules-deprecated#report-unused-eslint-disable-comments)
+     */
+    reportUnusedDisableDirectives?: boolean | undefined;
+    /**
+     * Settings.
+     *
+     * @see [Settings](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#adding-shared-settings)
+     */
+    settings?: SettingsConfig | undefined;
+}
+/**
+ * The overwrites that apply more differing configuration to specific files or directories.
+ */
+interface ConfigOverride<Rules extends RulesConfig = RulesConfig> extends BaseConfig<Rules> {
+    /**
+     * The glob patterns for excluded files.
+     */
+    excludedFiles?: string | string[] | undefined;
+    /**
+     * The glob patterns for target files.
+     */
+    files: string | string[];
+}
+/**
+ * ESLint legacy configuration.
+ *
+ * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+ */
+interface LegacyConfigObject<Rules extends RulesConfig = RulesConfig, OverrideRules extends RulesConfig = Rules> extends BaseConfig<Rules, OverrideRules> {
+    /**
+     * Tell ESLint to ignore specific files and directories.
+     *
+     * @see [Ignore Patterns](https://eslint.org/docs/latest/use/configure/ignore-deprecated#ignorepatterns-in-config-files)
+     */
+    ignorePatterns?: string | string[] | undefined;
+    /**
+     * @see [Using Configuration Files](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#using-configuration-files)
+     */
+    root?: boolean | undefined;
+}
+/**
+ * File information passed to a processor.
+ */
+interface ProcessorFile {
+    text: string;
+    filename: string;
+}
+/**
+ * A processor is an object that can preprocess and postprocess files.
+ */
+interface Processor<T extends string | ProcessorFile = string | ProcessorFile> extends ObjectMetaProperties {
+    /** If `true` then it means the processor supports autofix. */
+    supportsAutofix?: boolean | undefined;
+    /** The function to extract code blocks. */
+    preprocess?(text: string, filename: string): T[];
+    /** The function to merge messages. */
+    postprocess?(messages: LintMessage[][], filename: string): LintMessage[];
+}
+interface Plugin extends ObjectMetaProperties {
+    meta?: ObjectMetaProperties["meta"] & {
+        namespace?: string | undefined;
+    };
+    configs?: Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]> | undefined;
+    environments?: Record<string, EnvironmentConfig> | undefined;
+    languages?: Record<string, Language> | undefined;
+    processors?: Record<string, Processor> | undefined;
+    rules?: Record<string, RuleDefinition> | undefined;
+}
+/**
+ * Generic options for the `Language` type.
+ */
+interface LanguageTypeOptions {
+    LangOptions: LanguageOptions;
+    Code: SourceCode;
+    RootNode: unknown;
+    Node: unknown;
+}
+/**
+ * Represents a plugin language.
+ */
+interface Language<Options extends LanguageTypeOptions = {
+    LangOptions: LanguageOptions;
+    Code: SourceCode;
+    RootNode: unknown;
+    Node: unknown;
+}> {
+    /**
+     * Indicates how ESLint should read the file.
+     */
+    fileType: "text";
+    /**
+     * First line number returned from the parser (text mode only).
+     */
+    lineStart: 0 | 1;
+    /**
+     * First column number returned from the parser (text mode only).
+     */
+    columnStart: 0 | 1;
+    /**
+     * The property to read the node type from. Used in selector querying.
+     */
+    nodeTypeKey: string;
+    /**
+     * The traversal path that tools should take when evaluating the AST
+     */
+    visitorKeys?: Record<string, string[]>;
+    /**
+     * Default language options. User-defined options are merged with this object.
+     */
+    defaultLanguageOptions?: LanguageOptions;
+    /**
+     * Validates languageOptions for this language.
+     */
+    validateLanguageOptions(languageOptions: Options["LangOptions"]): void;
+    /**
+     * Normalizes languageOptions for this language.
+     */
+    normalizeLanguageOptions?(languageOptions: Options["LangOptions"]): Options["LangOptions"];
+    /**
+     * Helper for esquery that allows languages to match nodes against
+     * class. esquery currently has classes like `function` that will
+     * match all the various function nodes. This method allows languages
+     * to implement similar shorthands.
+     */
+    matchesSelectorClass?(className: string, node: Options["Node"], ancestry: Options["Node"][]): boolean;
+    /**
+     * Parses the given file input into its component parts. This file should not
+     * throws errors for parsing errors but rather should return any parsing
+     * errors as parse of the ParseResult object.
+     */
+    parse(file: File, context: LanguageContext<Options["LangOptions"]>): ParseResult<Options["RootNode"]>;
+    /**
+     * Creates SourceCode object that ESLint uses to work with a file.
+     */
+    createSourceCode(file: File, input: OkParseResult<Options["RootNode"]>, context: LanguageContext<Options["LangOptions"]>): Options["Code"];
+}
+/**
+ * Plugin-defined options for the language.
+ */
+type LanguageOptions = Record<string, unknown>;
+/**
+ * The context object that is passed to the language plugin methods.
+ */
+interface LanguageContext<LangOptions = LanguageOptions> {
+    languageOptions: LangOptions;
+}
+/**
+ * Represents a file read by ESLint.
+ */
+interface File {
+    /**
+     * The path that ESLint uses for this file. May be a virtual path
+     * if it was returned by a processor.
+     */
+    path: string;
+    /**
+     * The path to the file on disk. This always maps directly to a file
+     * regardless of whether it was returned from a processor.
+     */
+    physicalPath: string;
+    /**
+     * Indicates if the original source contained a byte-order marker.
+     * ESLint strips the BOM from the `body`, but this info is needed
+     * to correctly apply autofixing.
+     */
+    bom: boolean;
+    /**
+     * The body of the file to parse.
+     */
+    body: string | Uint8Array;
+}
+/**
+ * Represents the successful result of parsing a file.
+ */
+interface OkParseResult<RootNode = unknown> {
+    /**
+     * Indicates if the parse was successful. If true, the parse was successful
+     * and ESLint should continue on to create a SourceCode object and run rules;
+     * if false, ESLint should just report the error(s) without doing anything
+     * else.
+     */
+    ok: true;
+    /**
+     * The abstract syntax tree created by the parser. (only when ok: true)
+     */
+    ast: RootNode;
+    /**
+     * Any additional data that the parser wants to provide.
+     */
+    [key: string]: any;
+}
+/**
+ * Represents the unsuccessful result of parsing a file.
+ */
+interface NotOkParseResult {
+    /**
+     * Indicates if the parse was successful. If true, the parse was successful
+     * and ESLint should continue on to create a SourceCode object and run rules;
+     * if false, ESLint should just report the error(s) without doing anything
+     * else.
+     */
+    ok: false;
+    /**
+     * Any parsing errors, whether fatal or not. (only when ok: false)
+     */
+    errors: FileError[];
+    /**
+     * Any additional data that the parser wants to provide.
+     */
+    [key: string]: any;
+}
+type ParseResult<RootNode = unknown> = OkParseResult<RootNode> | NotOkParseResult;
+/**
+ * Represents inline configuration found in the source code.
+ */
+interface InlineConfigElement {
+    /**
+     * The location of the inline config element.
+     */
+    loc: SourceLocation;
+    /**
+     * The interpreted configuration from the inline config element.
+     */
+    config: {
+        rules: RulesConfig;
+    };
+}
+/**
+ * Generic options for the `SourceCodeBase` type.
+ */
+interface SourceCodeBaseTypeOptions {
+    LangOptions: LanguageOptions;
+    RootNode: unknown;
+    SyntaxElementWithLoc: unknown;
+    ConfigNode: unknown;
+}
+/**
+ * Represents the basic interface for a source code object.
+ */
+interface SourceCodeBase<Options extends SourceCodeBaseTypeOptions = {
+    LangOptions: LanguageOptions;
+    RootNode: unknown;
+    SyntaxElementWithLoc: unknown;
+    ConfigNode: unknown;
+}> {
+    /**
+     * Root of the AST.
+     */
+    ast: Options["RootNode"];
+    /**
+     * The traversal path that tools should take when evaluating the AST.
+     * When present, this overrides the `visitorKeys` on the language for
+     * just this source code object.
+     */
+    visitorKeys?: Record<string, string[]>;
+    /**
+     * Retrieves the equivalent of `loc` for a given node or token.
+     * @param syntaxElement The node or token to get the location for.
+     * @returns The location of the node or token.
+     */
+    getLoc(syntaxElement: Options["SyntaxElementWithLoc"]): SourceLocation;
+    /**
+     * Retrieves the equivalent of `range` for a given node or token.
+     * @param syntaxElement The node or token to get the range for.
+     * @returns The range of the node or token.
+     */
+    getRange(syntaxElement: Options["SyntaxElementWithLoc"]): SourceRange;
+    /**
+     * Traversal of AST.
+     */
+    traverse(): Iterable<TraversalStep>;
+    /**
+     * Applies language options passed in from the ESLint core.
+     */
+    applyLanguageOptions?(languageOptions: Options["LangOptions"]): void;
+    /**
+     * Return all of the inline areas where ESLint should be disabled/enabled
+     * along with any problems found in evaluating the directives.
+     */
+    getDisableDirectives?(): {
+        directives: Directive[];
+        problems: FileProblem[];
+    };
+    /**
+     * Returns an array of all inline configuration nodes found in the
+     * source code.
+     */
+    getInlineConfigNodes?(): Options["ConfigNode"][];
+    /**
+     * Applies configuration found inside of the source code. This method is only
+     * called when ESLint is running with inline configuration allowed.
+     */
+    applyInlineConfig?(): {
+        configs: InlineConfigElement[];
+        problems: FileProblem[];
+    };
+    /**
+     * Called by ESLint core to indicate that it has finished providing
+     * information. We now add in all the missing variables and ensure that
+     * state-changing methods cannot be called by rules.
+     * @returns {void}
+     */
+    finalize?(): void;
+}
+/**
+ * Represents the source of a text file being linted.
+ */
+interface TextSourceCode<Options extends SourceCodeBaseTypeOptions = {
+    LangOptions: LanguageOptions;
+    RootNode: unknown;
+    SyntaxElementWithLoc: unknown;
+    ConfigNode: unknown;
+}> extends SourceCodeBase<Options> {
+    /**
+     * The body of the file that you'd like rule developers to access.
+     */
+    text: string;
+}
+/**
+ * Represents the source of a binary file being linted.
+ */
+interface BinarySourceCode<Options extends SourceCodeBaseTypeOptions = {
+    LangOptions: LanguageOptions;
+    RootNode: unknown;
+    SyntaxElementWithLoc: unknown;
+    ConfigNode: unknown;
+}> extends SourceCodeBase<Options> {
+    /**
+     * The body of the file that you'd like rule developers to access.
+     */
+    body: Uint8Array;
+}
+type SourceCode<Options extends SourceCodeBaseTypeOptions = {
+    LangOptions: LanguageOptions;
+    RootNode: unknown;
+    SyntaxElementWithLoc: unknown;
+    ConfigNode: unknown;
+}> = TextSourceCode<Options> | BinarySourceCode<Options>;
+/**
+ * Represents a traversal step visiting the AST.
+ */
+interface VisitTraversalStep {
+    kind: 1;
+    target: unknown;
+    phase: 1 | 2;
+    args: unknown[];
+}
+/**
+ * Represents a traversal step calling a function.
+ */
+interface CallTraversalStep {
+    kind: 2;
+    target: string;
+    phase?: string;
+    args: unknown[];
+}
+type TraversalStep = VisitTraversalStep | CallTraversalStep;
+/**
+ * The type of disable directive. This determines how ESLint will disable rules.
+ */
+type DirectiveType = "disable" | "enable" | "disable-line" | "disable-next-line";
+/**
+ * Represents a disable directive.
+ */
+interface Directive {
+    /**
+     * The type of directive.
+     */
+    type: DirectiveType;
+    /**
+     * The node of the directive. May be in the AST or a comment/token.
+     */
+    node: unknown;
+    /**
+     * The value of the directive.
+     */
+    value: string;
+    /**
+     * The justification for the directive.
+     */
+    justification?: string;
 }
-declare function typescriptConventions(options?: TypescriptConventionsOptions): typescript_eslint.FlatConfig.ConfigArray;
+
+type TypescriptConventionsOptions = {
+    files?: string[];
+};
+declare function typescriptConventions(options?: TypescriptConventionsOptions): ({
+    files: string[];
+    plugins: {
+        import: Plugin & {
+            meta: {
+                name: string;
+                version: string;
+            };
+            configs: {
+                "recommended": eslint.Linter.LegacyConfig;
+                "errors": eslint.Linter.LegacyConfig;
+                "warnings": eslint.Linter.LegacyConfig;
+                "stage-0": eslint.Linter.LegacyConfig;
+                "react": eslint.Linter.LegacyConfig;
+                "react-native": eslint.Linter.LegacyConfig;
+                "electron": eslint.Linter.LegacyConfig;
+                "typescript": eslint.Linter.LegacyConfig;
+            };
+            flatConfigs: {
+                "recommended": eslint.Linter.FlatConfig;
+                "errors": eslint.Linter.FlatConfig;
+                "warnings": eslint.Linter.FlatConfig;
+                "stage-0": eslint.Linter.FlatConfig;
+                "react": eslint.Linter.FlatConfig;
+                "react-native": eslint.Linter.FlatConfig;
+                "electron": eslint.Linter.FlatConfig;
+                "typescript": eslint.Linter.FlatConfig;
+            };
+            rules: {
+                [key: string]: eslint.Rule.RuleModule;
+            };
+        };
+    };
+    rules: {
+        "import/no-default-export": string;
+        "@typescript-eslint/consistent-type-definitions": string[];
+        "@typescript-eslint/consistent-type-imports": string;
+        "prefer-arrow-callback": string;
+    };
+} | {
+    files: string[];
+    rules: {
+        "import/no-default-export": string;
+        "@typescript-eslint/consistent-type-definitions"?: undefined;
+        "@typescript-eslint/consistent-type-imports"?: undefined;
+        "prefer-arrow-callback"?: undefined;
+    };
+    plugins?: undefined;
+})[];
 
 type TypescriptConfigFiles = string[];
-interface TypescriptMinimalOptions {
+type TypescriptMinimalOptions = {
     files?: TypescriptConfigFiles;
-}
+};
 /**
  * MVP TypeScript profile.
  *
@@ -23,14 +1256,47 @@ interface TypescriptMinimalOptions {
  * @param options - Configuration options.
  * @returns The ESLint configuration.
  */
-declare function typescriptMinimal(options?: TypescriptMinimalOptions): typescript_eslint.FlatConfig.ConfigArray;
+declare function typescriptMinimal(options?: TypescriptMinimalOptions): {
+    files: string[];
+    plugins: {
+        "@typescript-eslint": CompatiblePlugin;
+    };
+    languageOptions: {
+        parser: CompatibleParser;
+        parserOptions: {
+            ecmaVersion: string;
+            sourceType: string;
+        };
+    };
+    rules: {
+        "@typescript-eslint/consistent-type-imports": string;
+        "@typescript-eslint/no-unused-vars": string;
+        "@typescript-eslint/no-shadow": string;
+        "@typescript-eslint/ban-ts-comment": string;
+        "@typescript-eslint/no-explicit-any": string;
+        "@typescript-eslint/no-inferrable-types": string;
+        "no-undef": string;
+        "no-unused-vars": string;
+        "no-var": string;
+        "prefer-const": string;
+        eqeqeq: (string | {
+            null: string;
+        })[];
+        "no-implicit-coercion": string;
+    };
+}[];
 
-interface TypescriptPrettierOptions {
+type TypescriptPrettierOptions = {
     files?: string[];
-}
-declare function typescriptPrettierInterop(options?: TypescriptPrettierOptions): typescript_eslint.FlatConfig.ConfigArray;
+};
+declare function typescriptPrettierInterop(options?: TypescriptPrettierOptions): {
+    files: string[];
+    rules: {
+        [x: string]: 0 | "off";
+    };
+}[];
 
-interface TypescriptRecommendedOptions {
+type TypescriptRecommendedOptions = {
     /**
      * When set, enables type-aware rules (more powerful, can be slower).
      *
@@ -51,17 +1317,583 @@ interface TypescriptRecommendedOptions {
      * When true (default), enables strict conventions (e.g. no default exports).
      */
     enableConventions?: boolean;
-}
-declare function typescriptRecommended(options?: TypescriptRecommendedOptions): typescript_eslint.FlatConfig.ConfigArray;
+};
+declare function typescriptRecommended(options?: TypescriptRecommendedOptions): ({
+    files: string[];
+    plugins: {
+        "@typescript-eslint": CompatiblePlugin;
+    };
+    languageOptions: {
+        parser: CompatibleParser;
+        parserOptions: {
+            ecmaVersion: string;
+            sourceType: string;
+        };
+    };
+    rules: {
+        "@typescript-eslint/consistent-type-imports": string;
+        "@typescript-eslint/no-unused-vars": string;
+        "@typescript-eslint/no-shadow": string;
+        "@typescript-eslint/ban-ts-comment": string;
+        "@typescript-eslint/no-explicit-any": string;
+        "@typescript-eslint/no-inferrable-types": string;
+        "no-undef": string;
+        "no-unused-vars": string;
+        "no-var": string;
+        "prefer-const": string;
+        eqeqeq: (string | {
+            null: string;
+        })[];
+        "no-implicit-coercion": string;
+    };
+} | {
+    files: string[];
+    plugins: {
+        import: Plugin & {
+            meta: {
+                name: string;
+                version: string;
+            };
+            configs: {
+                "recommended": eslint.Linter.LegacyConfig;
+                "errors": eslint.Linter.LegacyConfig;
+                "warnings": eslint.Linter.LegacyConfig;
+                "stage-0": eslint.Linter.LegacyConfig;
+                "react": eslint.Linter.LegacyConfig;
+                "react-native": eslint.Linter.LegacyConfig;
+                "electron": eslint.Linter.LegacyConfig;
+                "typescript": eslint.Linter.LegacyConfig;
+            };
+            flatConfigs: {
+                "recommended": eslint.Linter.FlatConfig;
+                "errors": eslint.Linter.FlatConfig;
+                "warnings": eslint.Linter.FlatConfig;
+                "stage-0": eslint.Linter.FlatConfig;
+                "react": eslint.Linter.FlatConfig;
+                "react-native": eslint.Linter.FlatConfig;
+                "electron": eslint.Linter.FlatConfig;
+                "typescript": eslint.Linter.FlatConfig;
+            };
+            rules: {
+                [key: string]: eslint.Rule.RuleModule;
+            };
+        };
+    };
+    rules: {
+        "import/no-default-export": string;
+        "@typescript-eslint/consistent-type-definitions": string[];
+        "@typescript-eslint/consistent-type-imports": string;
+        "prefer-arrow-callback": string;
+    };
+} | {
+    files: string[];
+    rules: {
+        "import/no-default-export": string;
+        "@typescript-eslint/consistent-type-definitions"?: undefined;
+        "@typescript-eslint/consistent-type-imports"?: undefined;
+        "prefer-arrow-callback"?: undefined;
+    };
+    plugins?: undefined;
+} | {
+    files: string[];
+    plugins: {
+        jsdoc: Plugin & {
+            configs: Record<`flat/${eslint_plugin_jsdoc.ConfigGroups}${eslint_plugin_jsdoc.ConfigVariants}${eslint_plugin_jsdoc.ErrorLevelVariants}`, eslint.Linter.Config> & Record<"examples" | "default-expressions" | "examples-and-default-expressions", eslint.Linter.Config[]> & Record<"flat/recommended-mixed", eslint.Linter.Config[]>;
+        };
+        "eslint-comments": typeof comments;
+    };
+    rules: {
+        "eslint-comments/no-unused-disable": string;
+        "eslint-comments/no-unlimited-disable": string;
+        "eslint-comments/require-description": string;
+        "eslint-comments/disable-enable-pair": string;
+        "jsdoc/check-alignment": string;
+        "jsdoc/require-param": string;
+        "jsdoc/require-returns": string;
+    };
+} | {
+    files: string[];
+    plugins: {
+        import: Plugin & {
+            meta: {
+                name: string;
+                version: string;
+            };
+            configs: {
+                "recommended": eslint.Linter.LegacyConfig;
+                "errors": eslint.Linter.LegacyConfig;
+                "warnings": eslint.Linter.LegacyConfig;
+                "stage-0": eslint.Linter.LegacyConfig;
+                "react": eslint.Linter.LegacyConfig;
+                "react-native": eslint.Linter.LegacyConfig;
+                "electron": eslint.Linter.LegacyConfig;
+                "typescript": eslint.Linter.LegacyConfig;
+            };
+            flatConfigs: {
+                "recommended": eslint.Linter.FlatConfig;
+                "errors": eslint.Linter.FlatConfig;
+                "warnings": eslint.Linter.FlatConfig;
+                "stage-0": eslint.Linter.FlatConfig;
+                "react": eslint.Linter.FlatConfig;
+                "react-native": eslint.Linter.FlatConfig;
+                "electron": eslint.Linter.FlatConfig;
+                "typescript": eslint.Linter.FlatConfig;
+            };
+            rules: {
+                [key: string]: eslint.Rule.RuleModule;
+            };
+        };
+        "simple-import-sort": Plugin;
+    };
+    settings: {
+        "import/parsers": {
+            "@typescript-eslint/parser": string[];
+        };
+        "import/resolver": {
+            typescript: {
+                alwaysTryTypes: boolean;
+                project: string[];
+            };
+            node: boolean;
+        };
+    };
+    rules: RulesConfig;
+} | {
+    files: string[];
+    plugins: {
+        unicorn: Plugin & {
+            configs: {
+                recommended: eslint.Linter.FlatConfig;
+                unopinionated: eslint.Linter.FlatConfig;
+                all: eslint.Linter.FlatConfig;
+                "flat/all": eslint.Linter.FlatConfig;
+                "flat/recommended": eslint.Linter.FlatConfig;
+            };
+        };
+    };
+    rules: RulesConfig;
+} | {
+    files: string[];
+    plugins: {
+        unicorn: Plugin & {
+            configs: {
+                recommended: eslint.Linter.FlatConfig;
+                unopinionated: eslint.Linter.FlatConfig;
+                all: eslint.Linter.FlatConfig;
+                "flat/all": eslint.Linter.FlatConfig;
+                "flat/recommended": eslint.Linter.FlatConfig;
+            };
+        };
+        sonarjs: {
+            rules: {
+                "function-name": eslint.Rule.RuleModule;
+                "class-name": eslint.Rule.RuleModule;
+                "max-lines": eslint.Rule.RuleModule;
+                "no-tab": eslint.Rule.RuleModule;
+                "variable-name": eslint.Rule.RuleModule;
+                "comment-regex": eslint.Rule.RuleModule;
+                "no-commented-code": eslint.Rule.RuleModule;
+                "elseif-without-else": eslint.Rule.RuleModule;
+                "no-fallthrough": eslint.Rule.RuleModule;
+                "nested-control-flow": eslint.Rule.RuleModule;
+                "too-many-break-or-continue-in-loop": eslint.Rule.RuleModule;
+                "max-lines-per-function": eslint.Rule.RuleModule;
+                "no-nested-incdec": eslint.Rule.RuleModule;
+                "no-equals-in-for-termination": eslint.Rule.RuleModule;
+                "no-extra-arguments": eslint.Rule.RuleModule;
+                "no-collapsible-if": eslint.Rule.RuleModule;
+                "expression-complexity": eslint.Rule.RuleModule;
+                "no-redundant-parentheses": eslint.Rule.RuleModule;
+                "no-labels": eslint.Rule.RuleModule;
+                "no-nested-assignment": eslint.Rule.RuleModule;
+                "no-redundant-boolean": eslint.Rule.RuleModule;
+                "prefer-single-boolean-return": eslint.Rule.RuleModule;
+                "unused-import": eslint.Rule.RuleModule;
+                "fixme-tag": eslint.Rule.RuleModule;
+                "todo-tag": eslint.Rule.RuleModule;
+                "useless-string-operation": eslint.Rule.RuleModule;
+                "no-unused-function-argument": eslint.Rule.RuleModule;
+                "no-duplicate-string": eslint.Rule.RuleModule;
+                "no-case-label-in-switch": eslint.Rule.RuleModule;
+                "no-parameter-reassignment": eslint.Rule.RuleModule;
+                "prefer-while": eslint.Rule.RuleModule;
+                "no-sonar-comments": eslint.Rule.RuleModule;
+                "no-small-switch": eslint.Rule.RuleModule;
+                "no-hardcoded-ip": eslint.Rule.RuleModule;
+                "label-position": eslint.Rule.RuleModule;
+                "public-static-readonly": eslint.Rule.RuleModule;
+                "file-header": eslint.Rule.RuleModule;
+                "call-argument-line": eslint.Rule.RuleModule;
+                "max-switch-cases": eslint.Rule.RuleModule;
+                "no-unused-vars": eslint.Rule.RuleModule;
+                "prefer-immediate-return": eslint.Rule.RuleModule;
+                "function-inside-loop": eslint.Rule.RuleModule;
+                "code-eval": eslint.Rule.RuleModule;
+                "no-variable-usage-before-declaration": eslint.Rule.RuleModule;
+                "future-reserved-words": eslint.Rule.RuleModule;
+                "array-constructor": eslint.Rule.RuleModule;
+                "bitwise-operators": eslint.Rule.RuleModule;
+                "no-function-declaration-in-block": eslint.Rule.RuleModule;
+                "no-primitive-wrappers": eslint.Rule.RuleModule;
+                "for-in": eslint.Rule.RuleModule;
+                "cyclomatic-complexity": eslint.Rule.RuleModule;
+                "no-skipped-tests": eslint.Rule.RuleModule;
+                "no-identical-expressions": eslint.Rule.RuleModule;
+                "no-nested-switch": eslint.Rule.RuleModule;
+                "constructor-for-side-effects": eslint.Rule.RuleModule;
+                "no-dead-store": eslint.Rule.RuleModule;
+                "no-identical-conditions": eslint.Rule.RuleModule;
+                "no-duplicated-branches": eslint.Rule.RuleModule;
+                deprecation: eslint.Rule.RuleModule;
+                "no-inverted-boolean-check": eslint.Rule.RuleModule;
+                "misplaced-loop-counter": eslint.Rule.RuleModule;
+                "no-nested-functions": eslint.Rule.RuleModule;
+                "no-hardcoded-passwords": eslint.Rule.RuleModule;
+                "sql-queries": eslint.Rule.RuleModule;
+                "insecure-cookie": eslint.Rule.RuleModule;
+                "no-useless-increment": eslint.Rule.RuleModule;
+                "no-globals-shadowing": eslint.Rule.RuleModule;
+                "no-undefined-assignment": eslint.Rule.RuleModule;
+                "no-empty-test-file": eslint.Rule.RuleModule;
+                "no-ignored-return": eslint.Rule.RuleModule;
+                "no-wildcard-import": eslint.Rule.RuleModule;
+                "arguments-order": eslint.Rule.RuleModule;
+                "pseudo-random": eslint.Rule.RuleModule;
+                "for-loop-increment-sign": eslint.Rule.RuleModule;
+                cookies: eslint.Rule.RuleModule;
+                "null-dereference": eslint.Rule.RuleModule;
+                "no-selector-parameter": eslint.Rule.RuleModule;
+                "updated-loop-counter": eslint.Rule.RuleModule;
+                "block-scoped-var": eslint.Rule.RuleModule;
+                "no-built-in-override": eslint.Rule.RuleModule;
+                "prefer-object-literal": eslint.Rule.RuleModule;
+                "no-ignored-exceptions": eslint.Rule.RuleModule;
+                "no-gratuitous-expressions": eslint.Rule.RuleModule;
+                "file-uploads": eslint.Rule.RuleModule;
+                "file-permissions": eslint.Rule.RuleModule;
+                "no-empty-character-class": eslint.Rule.RuleModule;
+                "no-unenclosed-multiline-block": eslint.Rule.RuleModule;
+                "index-of-compare-to-positive-number": eslint.Rule.RuleModule;
+                "assertions-in-tests": eslint.Rule.RuleModule;
+                "no-implicit-global": eslint.Rule.RuleModule;
+                "no-useless-catch": eslint.Rule.RuleModule;
+                "xml-parser-xxe": eslint.Rule.RuleModule;
+                "non-existent-operator": eslint.Rule.RuleModule;
+                "web-sql-database": eslint.Rule.RuleModule;
+                "post-message": eslint.Rule.RuleModule;
+                "no-array-delete": eslint.Rule.RuleModule;
+                "no-alphabetical-sort": eslint.Rule.RuleModule;
+                "no-incomplete-assertions": eslint.Rule.RuleModule;
+                "no-global-this": eslint.Rule.RuleModule;
+                "new-operator-misuse": eslint.Rule.RuleModule;
+                "no-delete-var": eslint.Rule.RuleModule;
+                "strings-comparison": eslint.Rule.RuleModule;
+                "file-name-differ-from-class": eslint.Rule.RuleModule;
+                "cookie-no-httponly": eslint.Rule.RuleModule;
+                "no-nested-conditional": eslint.Rule.RuleModule;
+                "no-incorrect-string-concat": eslint.Rule.RuleModule;
+                "different-types-comparison": eslint.Rule.RuleModule;
+                "inverted-assertion-arguments": eslint.Rule.RuleModule;
+                "shorthand-property-grouping": eslint.Rule.RuleModule;
+                "updated-const-var": eslint.Rule.RuleModule;
+                "arguments-usage": eslint.Rule.RuleModule;
+                "destructuring-assignment-syntax": eslint.Rule.RuleModule;
+                "no-invariant-returns": eslint.Rule.RuleModule;
+                "arrow-function-convention": eslint.Rule.RuleModule;
+                "class-prototype": eslint.Rule.RuleModule;
+                "generator-without-yield": eslint.Rule.RuleModule;
+                "no-require-or-define": eslint.Rule.RuleModule;
+                "no-associative-arrays": eslint.Rule.RuleModule;
+                "comma-or-logical-or-case": eslint.Rule.RuleModule;
+                "no-redundant-jump": eslint.Rule.RuleModule;
+                "inconsistent-function-call": eslint.Rule.RuleModule;
+                "no-use-of-empty-return-value": eslint.Rule.RuleModule;
+                "enforce-trailing-comma": {
+                    meta: _eslint_core.RulesMeta<string, unknown[], unknown>;
+                    create(context: eslint.Rule.RuleContext): eslint.Rule.NodeListener;
+                };
+                "void-use": eslint.Rule.RuleModule;
+                "operation-returning-nan": eslint.Rule.RuleModule;
+                "values-not-convertible-to-numbers": eslint.Rule.RuleModule;
+                "non-number-in-arithmetic-expression": eslint.Rule.RuleModule;
+                "cognitive-complexity": eslint.Rule.RuleModule;
+                "argument-type": eslint.Rule.RuleModule;
+                "in-operator-type-error": eslint.Rule.RuleModule;
+                "array-callback-without-return": eslint.Rule.RuleModule;
+                "declarations-in-global-scope": eslint.Rule.RuleModule;
+                "function-return-type": eslint.Rule.RuleModule;
+                "no-inconsistent-returns": eslint.Rule.RuleModule;
+                "no-reference-error": eslint.Rule.RuleModule;
+                "super-invocation": eslint.Rule.RuleModule;
+                "no-all-duplicated-branches": eslint.Rule.RuleModule;
+                "no-same-line-conditional": eslint.Rule.RuleModule;
+                "conditional-indentation": eslint.Rule.RuleModule;
+                "no-collection-size-mischeck": eslint.Rule.RuleModule;
+                "no-unthrown-error": eslint.Rule.RuleModule;
+                "no-unused-collection": eslint.Rule.RuleModule;
+                "no-os-command-from-path": eslint.Rule.RuleModule;
+                "no-misleading-array-reverse": eslint.Rule.RuleModule;
+                "no-for-in-iterable": eslint.Rule.RuleModule;
+                "no-element-overwrite": eslint.Rule.RuleModule;
+                "no-identical-functions": eslint.Rule.RuleModule;
+                "no-empty-collection": eslint.Rule.RuleModule;
+                "no-redundant-assignments": eslint.Rule.RuleModule;
+                "prefer-type-guard": eslint.Rule.RuleModule;
+                "use-type-alias": eslint.Rule.RuleModule;
+                "no-return-type-any": eslint.Rule.RuleModule;
+                "no-implicit-dependencies": eslint.Rule.RuleModule;
+                "no-useless-intersection": eslint.Rule.RuleModule;
+                "weak-ssl": eslint.Rule.RuleModule;
+                "no-weak-keys": eslint.Rule.RuleModule;
+                csrf: eslint.Rule.RuleModule;
+                "production-debug": eslint.Rule.RuleModule;
+                "prefer-default-last": eslint.Rule.RuleModule;
+                "no-in-misuse": eslint.Rule.RuleModule;
+                "no-duplicate-in-composite": eslint.Rule.RuleModule;
+                "max-union-size": eslint.Rule.RuleModule;
+                "no-undefined-argument": eslint.Rule.RuleModule;
+                "no-nested-template-literals": eslint.Rule.RuleModule;
+                "prefer-promise-shorthand": eslint.Rule.RuleModule;
+                "os-command": eslint.Rule.RuleModule;
+                "no-redundant-optional": eslint.Rule.RuleModule;
+                "regular-expr": eslint.Rule.RuleModule;
+                encryption: eslint.Rule.RuleModule;
+                hashing: eslint.Rule.RuleModule;
+                "bool-param-default": eslint.Rule.RuleModule;
+                xpath: eslint.Rule.RuleModule;
+                sockets: eslint.Rule.RuleModule;
+                "no-try-promise": eslint.Rule.RuleModule;
+                "process-argv": eslint.Rule.RuleModule;
+                "standard-input": eslint.Rule.RuleModule;
+                "unverified-certificate": eslint.Rule.RuleModule;
+                "no-unsafe-unzip": eslint.Rule.RuleModule;
+                cors: eslint.Rule.RuleModule;
+                "link-with-target-blank": eslint.Rule.RuleModule;
+                "disabled-auto-escaping": eslint.Rule.RuleModule;
+                "table-header": eslint.Rule.RuleModule;
+                "no-table-as-layout": eslint.Rule.RuleModule;
+                "table-header-reference": eslint.Rule.RuleModule;
+                "object-alt-content": eslint.Rule.RuleModule;
+                "no-clear-text-protocols": eslint.Rule.RuleModule;
+                "publicly-writable-directories": eslint.Rule.RuleModule;
+                "unverified-hostname": eslint.Rule.RuleModule;
+                "encryption-secure-mode": eslint.Rule.RuleModule;
+                "no-weak-cipher": eslint.Rule.RuleModule;
+                "no-intrusive-permissions": eslint.Rule.RuleModule;
+                "insecure-jwt-token": eslint.Rule.RuleModule;
+                "x-powered-by": eslint.Rule.RuleModule;
+                "hidden-files": eslint.Rule.RuleModule;
+                "content-length": eslint.Rule.RuleModule;
+                "disabled-resource-integrity": eslint.Rule.RuleModule;
+                "content-security-policy": eslint.Rule.RuleModule;
+                "no-mixed-content": eslint.Rule.RuleModule;
+                "frame-ancestors": eslint.Rule.RuleModule;
+                "no-mime-sniff": eslint.Rule.RuleModule;
+                "no-referrer-policy": eslint.Rule.RuleModule;
+                "strict-transport-security": eslint.Rule.RuleModule;
+                "certificate-transparency": eslint.Rule.RuleModule;
+                "dns-prefetching": eslint.Rule.RuleModule;
+                "confidential-information-logging": eslint.Rule.RuleModule;
+                "no-ip-forward": eslint.Rule.RuleModule;
+                "empty-string-repetition": eslint.Rule.RuleModule;
+                "regex-complexity": eslint.Rule.RuleModule;
+                "anchor-precedence": eslint.Rule.RuleModule;
+                "slow-regex": eslint.Rule.RuleModule;
+                "no-invalid-regexp": eslint.Rule.RuleModule;
+                "unused-named-groups": eslint.Rule.RuleModule;
+                "no-same-argument-assert": eslint.Rule.RuleModule;
+                "unicode-aware-regex": eslint.Rule.RuleModule;
+                "no-misleading-character-class": eslint.Rule.RuleModule;
+                "duplicates-in-character-class": eslint.Rule.RuleModule;
+                "session-regeneration": eslint.Rule.RuleModule;
+                "test-check-exception": eslint.Rule.RuleModule;
+                "stable-tests": eslint.Rule.RuleModule;
+                "no-empty-after-reluctant": eslint.Rule.RuleModule;
+                "single-character-alternation": eslint.Rule.RuleModule;
+                "no-code-after-done": eslint.Rule.RuleModule;
+                "disabled-timeout": eslint.Rule.RuleModule;
+                "chai-determinate-assertion": eslint.Rule.RuleModule;
+                "aws-s3-bucket-server-encryption": eslint.Rule.RuleModule;
+                "aws-s3-bucket-insecure-http": eslint.Rule.RuleModule;
+                "aws-s3-bucket-versioning": eslint.Rule.RuleModule;
+                "aws-s3-bucket-granted-access": eslint.Rule.RuleModule;
+                "no-angular-bypass-sanitization": eslint.Rule.RuleModule;
+                "aws-iam-public-access": eslint.Rule.RuleModule;
+                "aws-ec2-unencrypted-ebs-volume": eslint.Rule.RuleModule;
+                "aws-s3-bucket-public-access": eslint.Rule.RuleModule;
+                "no-vue-bypass-sanitization": eslint.Rule.RuleModule;
+                "aws-iam-all-privileges": eslint.Rule.RuleModule;
+                "aws-rds-unencrypted-databases": eslint.Rule.RuleModule;
+                "aws-iam-all-resources-accessible": eslint.Rule.RuleModule;
+                "aws-opensearchservice-domain": eslint.Rule.RuleModule;
+                "aws-iam-privilege-escalation": eslint.Rule.RuleModule;
+                "aws-sagemaker-unencrypted-notebook": eslint.Rule.RuleModule;
+                "aws-restricted-ip-admin-access": eslint.Rule.RuleModule;
+                "no-empty-alternatives": eslint.Rule.RuleModule;
+                "no-control-regex": eslint.Rule.RuleModule;
+                "no-regex-spaces": eslint.Rule.RuleModule;
+                "aws-sns-unencrypted-topics": eslint.Rule.RuleModule;
+                "existing-groups": eslint.Rule.RuleModule;
+                "aws-ec2-rds-dms-public": eslint.Rule.RuleModule;
+                "aws-sqs-unencrypted-queue": eslint.Rule.RuleModule;
+                "no-empty-group": eslint.Rule.RuleModule;
+                "aws-efs-unencrypted": eslint.Rule.RuleModule;
+                "aws-apigateway-public-api": eslint.Rule.RuleModule;
+                "stateful-regex": eslint.Rule.RuleModule;
+                "concise-regex": eslint.Rule.RuleModule;
+                "single-char-in-character-classes": eslint.Rule.RuleModule;
+                "no-hardcoded-secrets": eslint.Rule.RuleModule;
+                "no-exclusive-tests": eslint.Rule.RuleModule;
+                "jsx-no-leaked-render": eslint.Rule.RuleModule;
+                "no-hook-setter-in-body": eslint.Rule.RuleModule;
+                "no-useless-react-setstate": eslint.Rule.RuleModule;
+                "no-uniq-key": eslint.Rule.RuleModule;
+                "redundant-type-aliases": eslint.Rule.RuleModule;
+                "prefer-regexp-exec": eslint.Rule.RuleModule;
+                "no-internal-api-use": eslint.Rule.RuleModule;
+                "prefer-read-only-props": eslint.Rule.RuleModule;
+                "no-literal-call": eslint.Rule.RuleModule;
+                "reduce-initial-value": eslint.Rule.RuleModule;
+                "no-async-constructor": eslint.Rule.RuleModule;
+            };
+            configs: {
+                recommended: eslint.Linter.FlatConfig<eslint.Linter.RulesRecord>;
+                "recommended-legacy": eslint.Linter.LegacyConfig<eslint.Linter.RulesRecord, eslint.Linter.RulesRecord>;
+            };
+            meta: {
+                name: string;
+                version: string;
+            };
+        };
+    };
+    rules: {
+        "unicorn/prefer-node-protocol": string;
+        "unicorn/no-useless-undefined": string;
+        "unicorn/no-lonely-if": string;
+        "unicorn/prefer-optional-catch-binding": string;
+        "unicorn/prefer-string-replace-all": string;
+        "unicorn/prevent-abbreviations": (string | {
+            allowList: {
+                Props: boolean;
+                props: boolean;
+                Ref: boolean;
+                ref: boolean;
+                Src: boolean;
+                src: boolean;
+                Params: boolean;
+                params: boolean;
+                Env: boolean;
+                env: boolean;
+                Args: boolean;
+                args: boolean;
+                Docs: boolean;
+                docs: boolean;
+                arg: boolean;
+                err: boolean;
+                req: boolean;
+                res: boolean;
+                ctx: boolean;
+                val: boolean;
+            };
+        })[];
+        "consistent-return": string;
+        "no-implicit-coercion": string;
+        "sonarjs/cognitive-complexity": (string | number)[];
+        "sonarjs/no-identical-functions": string;
+        "sonarjs/no-duplicated-branches": string;
+        "sonarjs/no-redundant-boolean": string;
+        "sonarjs/no-inverted-boolean-check": string;
+    };
+} | {
+    files: string[];
+    plugins: {
+        security: typescript_eslint.FlatConfig.Plugin;
+        regexp: typeof eslint_plugin_regexp;
+    };
+    rules: {
+        "security/detect-object-injection": string;
+        "security/detect-unsafe-regex": string;
+        "regexp/no-super-linear-backtracking": string;
+        "regexp/no-useless-escape": string;
+        "regexp/no-empty-capturing-group": string;
+    };
+} | {
+    files: string[];
+    rules: {
+        "max-lines": (string | {
+            max: number;
+            skipBlankLines: boolean;
+            skipComments: boolean;
+        })[];
+        "max-lines-per-function": (string | {
+            max: number;
+            skipBlankLines: boolean;
+            skipComments: boolean;
+        })[];
+        complexity: (string | number)[];
+        "max-params": (string | number)[];
+        "max-depth": (string | number)[];
+        "no-var": string;
+        "prefer-const": string;
+    };
+} | {
+    files: string[];
+    plugins: {
+        "@typescript-eslint": CompatiblePlugin;
+    };
+    languageOptions: {
+        parserOptions: {
+            project: string | string[];
+            tsconfigRootDir: string | undefined;
+        };
+    };
+    rules: {
+        "@typescript-eslint/require-await": string;
+        "@typescript-eslint/no-floating-promises": string;
+        "@typescript-eslint/no-misused-promises": string;
+        "@typescript-eslint/await-thenable": string;
+        "@typescript-eslint/no-unnecessary-condition": string;
+        "@typescript-eslint/no-unnecessary-type-assertion": string;
+        "@typescript-eslint/restrict-template-expressions": string;
+        "@typescript-eslint/prefer-nullish-coalescing": string;
+        "@typescript-eslint/prefer-optional-chain": string;
+        "@typescript-eslint/switch-exhaustiveness-check": string;
+        "@typescript-eslint/no-deprecated": string;
+        "@typescript-eslint/consistent-type-exports": string;
+    };
+} | {
+    files: string[];
+    name?: string;
+    rules?: object;
+})[];
 
-interface TypescriptSecurityOptions {
+type TypescriptSecurityOptions = {
     files?: string[];
-}
+};
 
-interface TypescriptSizeComplexityOptions {
+type TypescriptSizeComplexityOptions = {
     files?: string[];
-}
-declare function typescriptSizeComplexity(options?: TypescriptSizeComplexityOptions): typescript_eslint.FlatConfig.ConfigArray;
+};
+declare function typescriptSizeComplexity(options?: TypescriptSizeComplexityOptions): {
+    files: string[];
+    rules: {
+        "max-lines": (string | {
+            max: number;
+            skipBlankLines: boolean;
+            skipComments: boolean;
+        })[];
+        "max-lines-per-function": (string | {
+            max: number;
+            skipBlankLines: boolean;
+            skipComments: boolean;
+        })[];
+        complexity: (string | number)[];
+        "max-params": (string | number)[];
+        "max-depth": (string | number)[];
+        "no-var": string;
+        "prefer-const": string;
+    };
+}[];
 
 /**
  * Placeholder for future custom rules.