code:
import { Linter } from "../index";

export interface StylisticIssues extends Linter.RulesRecord {
    /**
     * Rule to enforce linebreaks after opening and before closing array brackets.
     *
     * @since 4.0.0-alpha.1
     * @see https://eslint.org/docs/rules/array-bracket-newline
     */
    "array-bracket-newline": Linter.RuleEntry<
        [
            | "always"
            | "never"
            | "consistent"
            | Partial<{
                /**
                 * @default true
                 */
                multiline: boolean;
                /**
                 * @default null
                 */
                minItems: number | null;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent spacing inside array brackets.
     *
     * @since 0.24.0
     * @see https://eslint.org/docs/rules/array-bracket-spacing
     */
    "array-bracket-spacing":
        | Linter.RuleEntry<
            [
                "never",
                Partial<{
                    /**
                     * @default false
                     */
                    singleValue: boolean;
                    /**
                     * @default false
                     */
                    objectsInArrays: boolean;
                    /**
                     * @default false
                     */
                    arraysInArrays: boolean;
                }>,
            ]
        >
        | Linter.RuleEntry<
            [
                "always",
                Partial<{
                    /**
                     * @default true
                     */
                    singleValue: boolean;
                    /**
                     * @default true
                     */
                    objectsInArrays: boolean;
                    /**
                     * @default true
                     */
                    arraysInArrays: boolean;
                }>,
            ]
        >;

    /**
     * Rule to enforce line breaks after each array element.
     *
     * @since 4.0.0-rc.0
     * @see https://eslint.org/docs/rules/array-element-newline
     */
    "array-element-newline": Linter.RuleEntry<
        [
            | "always"
            | "never"
            | "consistent"
            | Partial<{
                /**
                 * @default true
                 */
                multiline: boolean;
                /**
                 * @default null
                 */
                minItems: number | null;
            }>,
        ]
    >;

    /**
     * Rule to disallow or enforce spaces inside of blocks after opening block and before closing block.
     *
     * @since 1.2.0
     * @see https://eslint.org/docs/rules/block-spacing
     */
    "block-spacing": Linter.RuleEntry<["always" | "never"]>;

    /**
     * Rule to enforce consistent brace style for blocks.
     *
     * @since 0.0.7
     * @see https://eslint.org/docs/rules/brace-style
     */
    "brace-style": Linter.RuleEntry<
        [
            "1tbs" | "stroustrup" | "allman",
            Partial<{
                /**
                 * @default false
                 */
                allowSingleLine: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce camelcase naming convention.
     *
     * @since 0.0.2
     * @see https://eslint.org/docs/rules/camelcase
     */
    camelcase: Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default 'always'
                 */
                properties: "always" | "never";
                /**
                 * @default false
                 */
                ignoreDestructuring: boolean;
                /**
                 * @remarks
                 * Also accept for regular expression patterns
                 */
                allow: string[];
            }>,
        ]
    >;

    /**
     * Rule to enforce or disallow capitalization of the first letter of a comment.
     *
     * @since 3.11.0
     * @see https://eslint.org/docs/rules/capitalized-comments
     */
    "capitalized-comments": Linter.RuleEntry<
        [
            "always" | "never",
            Partial<{
                ignorePattern: string;
                /**
                 * @default false
                 */
                ignoreInlineComments: boolean;
                /**
                 * @default false
                 */
                ignoreConsecutiveComments: boolean;
            }>,
        ]
    >;

    /**
     * Rule to require or disallow trailing commas.
     *
     * @since 0.16.0
     * @see https://eslint.org/docs/rules/comma-dangle
     */
    "comma-dangle": Linter.RuleEntry<
        [
            | "never"
            | "always"
            | "always-multiline"
            | "only-multiline"
            | Partial<{
                /**
                 * @default 'never'
                 */
                arrays: "never" | "always" | "always-multiline" | "only-multiline";
                /**
                 * @default 'never'
                 */
                objects: "never" | "always" | "always-multiline" | "only-multiline";
                /**
                 * @default 'never'
                 */
                imports: "never" | "always" | "always-multiline" | "only-multiline";
                /**
                 * @default 'never'
                 */
                exports: "never" | "always" | "always-multiline" | "only-multiline";
                /**
                 * @default 'never'
                 */
                functions: "never" | "always" | "always-multiline" | "only-multiline";
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent spacing before and after commas.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/comma-spacing
     */
    "comma-spacing": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                before: boolean;
                /**
                 * @default true
                 */
                after: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent comma style.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/comma-style
     */
    "comma-style": Linter.RuleEntry<
        [
            "last" | "first",
            Partial<{
                exceptions: Record<string, boolean>;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent spacing inside computed property brackets.
     *
     * @since 0.23.0
     * @see https://eslint.org/docs/rules/computed-property-spacing
     */
    "computed-property-spacing": Linter.RuleEntry<["never" | "always"]>;

    /**
     * Rule to enforce consistent naming when capturing the current execution context.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/consistent-this
     */
    "consistent-this": Linter.RuleEntry<[...string[]]>;

    /**
     * Rule to require or disallow newline at the end of files.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/eol-last
     */
    "eol-last": Linter.RuleEntry<
        [
            "always" | "never", // | 'unix' | 'windows'
        ]
    >;

    /**
     * Rule to require or disallow spacing between function identifiers and their invocations.
     *
     * @since 3.3.0
     * @see https://eslint.org/docs/rules/func-call-spacing
     */
    "func-call-spacing": Linter.RuleEntry<["never" | "always"]>;

    /**
     * Rule to require function names to match the name of the variable or property to which they are assigned.
     *
     * @since 3.8.0
     * @see https://eslint.org/docs/rules/func-name-matching
     */
    "func-name-matching":
        | Linter.RuleEntry<
            [
                "always" | "never",
                Partial<{
                    /**
                     * @default false
                     */
                    considerPropertyDescriptor: boolean;
                    /**
                     * @default false
                     */
                    includeCommonJSModuleExports: boolean;
                }>,
            ]
        >
        | Linter.RuleEntry<
            [
                Partial<{
                    /**
                     * @default false
                     */
                    considerPropertyDescriptor: boolean;
                    /**
                     * @default false
                     */
                    includeCommonJSModuleExports: boolean;
                }>,
            ]
        >;

    /**
     * Rule to require or disallow named `function` expressions.
     *
     * @since 0.4.0
     * @see https://eslint.org/docs/rules/func-names
     */
    "func-names": Linter.RuleEntry<
        [
            "always" | "as-needed" | "never",
            Partial<{
                generators: "always" | "as-needed" | "never";
            }>,
        ]
    >;

    /**
     * Rule to enforce the consistent use of either `function` declarations or expressions.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/func-style
     */
    "func-style": Linter.RuleEntry<
        [
            "expression" | "declaration",
            Partial<{
                /**
                 * @default false
                 */
                allowArrowFunctions: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent line breaks inside function parentheses.
     *
     * @since 4.6.0
     * @see https://eslint.org/docs/rules/function-paren-newline
     */
    "function-paren-newline": Linter.RuleEntry<
        [
            | "always"
            | "never"
            | "multiline"
            | "multiline-arguments"
            | "consistent"
            | Partial<{
                minItems: number;
            }>,
        ]
    >;

    /**
     * Rule to disallow specified identifiers.
     *
     * @since 2.0.0-beta.2
     * @see https://eslint.org/docs/rules/id-blacklist
     */
    "id-blacklist": Linter.RuleEntry<[...string[]]>;

    /**
     * Rule to enforce minimum and maximum identifier lengths.
     *
     * @since 1.0.0
     * @see https://eslint.org/docs/rules/id-length
     */
    "id-length": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default 2
                 */
                min: number;
                /**
                 * @default Infinity
                 */
                max: number;
                /**
                 * @default 'always'
                 */
                properties: "always" | "never";
                exceptions: string[];
            }>,
        ]
    >;

    /**
     * Rule to require identifiers to match a specified regular expression.
     *
     * @since 1.0.0
     * @see https://eslint.org/docs/rules/id-match
     */
    "id-match": Linter.RuleEntry<
        [
            string,
            Partial<{
                /**
                 * @default false
                 */
                properties: boolean;
                /**
                 * @default false
                 */
                onlyDeclarations: boolean;
                /**
                 * @default false
                 */
                ignoreDestructuring: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce the location of arrow function bodies.
     *
     * @since 4.12.0
     * @see https://eslint.org/docs/rules/implicit-arrow-linebreak
     */
    "implicit-arrow-linebreak": Linter.RuleEntry<["beside" | "below"]>;

    /**
     * Rule to enforce consistent indentation.
     *
     * @since 0.14.0
     * @see https://eslint.org/docs/rules/indent
     */
    indent: Linter.RuleEntry<
        [
            number | "tab",
            Partial<{
                /**
                 * @default 0
                 */
                SwitchCase: number;
                /**
                 * @default 1
                 */
                VariableDeclarator:
                    | Partial<{
                        /**
                         * @default 1
                         */
                        var: number | "first";
                        /**
                         * @default 1
                         */
                        let: number | "first";
                        /**
                         * @default 1
                         */
                        const: number | "first";
                    }>
                    | number
                    | "first";
                /**
                 * @default 1
                 */
                outerIIFEBody: number;
                /**
                 * @default 1
                 */
                MemberExpression: number | "off";
                /**
                 * @default { parameters: 1, body: 1 }
                 */
                FunctionDeclaration: Partial<{
                    /**
                     * @default 1
                     */
                    parameters: number | "first" | "off";
                    /**
                     * @default 1
                     */
                    body: number;
                }>;
                /**
                 * @default { parameters: 1, body: 1 }
                 */
                FunctionExpression: Partial<{
                    /**
                     * @default 1
                     */
                    parameters: number | "first" | "off";
                    /**
                     * @default 1
                     */
                    body: number;
                }>;
                /**
                 * @default { arguments: 1 }
                 */
                CallExpression: Partial<{
                    /**
                     * @default 1
                     */
                    arguments: number | "first" | "off";
                }>;
                /**
                 * @default 1
                 */
                ArrayExpression: number | "first" | "off";
                /**
                 * @default 1
                 */
                ObjectExpression: number | "first" | "off";
                /**
                 * @default 1
                 */
                ImportDeclaration: number | "first" | "off";
                /**
                 * @default false
                 */
                flatTernaryExpressions: boolean;
                ignoredNodes: string[];
                /**
                 * @default false
                 */
                ignoreComments: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce the consistent use of either double or single quotes in JSX attributes.
     *
     * @since 1.4.0
     * @see https://eslint.org/docs/rules/jsx-quotes
     */
    "jsx-quotes": Linter.RuleEntry<["prefer-double" | "prefer-single"]>;

    /**
     * Rule to enforce consistent spacing between keys and values in object literal properties.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/key-spacing
     */
    "key-spacing": Linter.RuleEntry<
        [
            | Partial<
                | {
                    /**
                     * @default false
                     */
                    beforeColon: boolean;
                    /**
                     * @default true
                     */
                    afterColon: boolean;
                    /**
                     * @default 'strict'
                     */
                    mode: "strict" | "minimum";
                    align:
                        | Partial<{
                            /**
                             * @default false
                             */
                            beforeColon: boolean;
                            /**
                             * @default true
                             */
                            afterColon: boolean;
                            /**
                             * @default 'colon'
                             */
                            on: "value" | "colon";
                            /**
                             * @default 'strict'
                             */
                            mode: "strict" | "minimum";
                        }>
                        | "value"
                        | "colon";
                }
                | {
                    singleLine?:
                        | Partial<{
                            /**
                             * @default false
                             */
                            beforeColon: boolean;
                            /**
                             * @default true
                             */
                            afterColon: boolean;
                            /**
                             * @default 'strict'
                             */
                            mode: "strict" | "minimum";
                        }>
                        | undefined;
                    multiLine?:
                        | Partial<{
                            /**
                             * @default false
                             */
                            beforeColon: boolean;
                            /**
                             * @default true
                             */
                            afterColon: boolean;
                            /**
                             * @default 'strict'
                             */
                            mode: "strict" | "minimum";
                            align:
                                | Partial<{
                                    /**
                                     * @default false
                                     */
                                    beforeColon: boolean;
                                    /**
                                     * @default true
                                     */
                                    afterColon: boolean;
                                    /**
                                     * @default 'colon'
                                     */
                                    on: "value" | "colon";
                                    /**
                                     * @default 'strict'
                                     */
                                    mode: "strict" | "minimum";
                                }>
                                | "value"
                                | "colon";
                        }>
                        | undefined;
                }
            >
            | {
                align: Partial<{
                    /**
                     * @default false
                     */
                    beforeColon: boolean;
                    /**
                     * @default true
                     */
                    afterColon: boolean;
                    /**
                     * @default 'colon'
                     */
                    on: "value" | "colon";
                    /**
                     * @default 'strict'
                     */
                    mode: "strict" | "minimum";
                }>;
                singleLine?:
                    | Partial<{
                        /**
                         * @default false
                         */
                        beforeColon: boolean;
                        /**
                         * @default true
                         */
                        afterColon: boolean;
                        /**
                         * @default 'strict'
                         */
                        mode: "strict" | "minimum";
                    }>
                    | undefined;
                multiLine?:
                    | Partial<{
                        /**
                         * @default false
                         */
                        beforeColon: boolean;
                        /**
                         * @default true
                         */
                        afterColon: boolean;
                        /**
                         * @default 'strict'
                         */
                        mode: "strict" | "minimum";
                    }>
                    | undefined;
            },
        ]
    >;

    /**
     * Rule to enforce consistent spacing before and after keywords.
     *
     * @since 2.0.0-beta.1
     * @see https://eslint.org/docs/rules/keyword-spacing
     */
    "keyword-spacing": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default true
                 */
                before: boolean;
                /**
                 * @default true
                 */
                after: boolean;
                overrides: Record<
                    string,
                    Partial<{
                        before: boolean;
                        after: boolean;
                    }>
                >;
            }>,
        ]
    >;

    /**
     * Rule to enforce position of line comments.
     *
     * @since 3.5.0
     * @see https://eslint.org/docs/rules/line-comment-position
     */
    "line-comment-position": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default 'above'
                 */
                position: "above" | "beside";
                ignorePattern: string;
                /**
                 * @default true
                 */
                applyDefaultIgnorePatterns: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent linebreak style.
     *
     * @since 0.21.0
     * @see https://eslint.org/docs/rules/linebreak-style
     */
    "linebreak-style": Linter.RuleEntry<["unix" | "windows"]>;

    /**
     * Rule to require empty lines around comments.
     *
     * @since 0.22.0
     * @see https://eslint.org/docs/rules/lines-around-comment
     */
    "lines-around-comment": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default true
                 */
                beforeBlockComment: boolean;
                /**
                 * @default false
                 */
                afterBlockComment: boolean;
                /**
                 * @default false
                 */
                beforeLineComment: boolean;
                /**
                 * @default false
                 */
                afterLineComment: boolean;
                /**
                 * @default false
                 */
                allowBlockStart: boolean;
                /**
                 * @default false
                 */
                allowBlockEnd: boolean;
                /**
                 * @default false
                 */
                allowObjectStart: boolean;
                /**
                 * @default false
                 */
                allowObjectEnd: boolean;
                /**
                 * @default false
                 */
                allowArrayStart: boolean;
                /**
                 * @default false
                 */
                allowArrayEnd: boolean;
                /**
                 * @default false
                 */
                allowClassStart: boolean;
                /**
                 * @default false
                 */
                allowClassEnd: boolean;
                ignorePattern: string;
                /**
                 * @default true
                 */
                applyDefaultIgnorePatterns: boolean;
            }>,
        ]
    >;

    /**
     * Rule to require or disallow an empty line between class members.
     *
     * @since 4.9.0
     * @see https://eslint.org/docs/rules/lines-between-class-members
     */
    "lines-between-class-members": Linter.RuleEntry<
        [
            "always" | "never",
            Partial<{
                /**
                 * @default false
                 */
                exceptAfterSingleLine: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce a maximum depth that blocks can be nested.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-depth
     */
    "max-depth": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default 4
                 */
                max: number;
            }>,
        ]
    >;

    /**
     * Rule to enforce a maximum line length.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-len
     */
    "max-len": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default 80
                 */
                code: number;
                /**
                 * @default 4
                 */
                tabWidth: number;
                comments: number;
                ignorePattern: string;
                /**
                 * @default false
                 */
                ignoreComments: boolean;
                /**
                 * @default false
                 */
                ignoreTrailingComments: boolean;
                /**
                 * @default false
                 */
                ignoreUrls: boolean;
                /**
                 * @default false
                 */
                ignoreStrings: boolean;
                /**
                 * @default false
                 */
                ignoreTemplateLiterals: boolean;
                /**
                 * @default false
                 */
                ignoreRegExpLiterals: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce a maximum number of lines per file.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/max-lines
     */
    "max-lines": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default 300
                 */
                max: number;
                /**
                 * @default false
                 */
                skipBlankLines: boolean;
                /**
                 * @default false
                 */
                skipComments: boolean;
            }>
            | number,
        ]
    >;

    /**
     * Rule to enforce a maximum number of line of code in a function.
     *
     * @since 5.0.0
     * @see https://eslint.org/docs/rules/max-lines-per-function
     */
    "max-lines-per-function": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default 50
                 */
                max: number;
                /**
                 * @default false
                 */
                skipBlankLines: boolean;
                /**
                 * @default false
                 */
                skipComments: boolean;
                /**
                 * @default false
                 */
                IIFEs: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce a maximum depth that callbacks can be nested.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/max-nested-callbacks
     */
    "max-nested-callbacks": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default 10
                 */
                max: number;
            }>
            | number,
        ]
    >;

    /**
     * Rule to enforce a maximum number of parameters in function definitions.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-params
     */
    "max-params": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default 3
                 */
                max: number;
            }>
            | number,
        ]
    >;

    /**
     * Rule to enforce a maximum number of statements allowed in function blocks.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-statements
     */
    "max-statements": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default 10
                 */
                max: number;
                /**
                 * @default false
                 */
                ignoreTopLevelFunctions: boolean;
            }>
            | number,
        ]
    >;

    /**
     * Rule to enforce a maximum number of statements allowed per line.
     *
     * @since 2.5.0
     * @see https://eslint.org/docs/rules/max-statements-per-line
     */
    "max-statements-per-line": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default 1
                 */
                max: number;
            }>
            | number,
        ]
    >;

    /**
     * Rule to enforce a particular style for multiline comments.
     *
     * @since 4.10.0
     * @see https://eslint.org/docs/rules/multiline-comment-style
     */
    "multiline-comment-style": Linter.RuleEntry<["starred-block" | "bare-block" | "separate-lines"]>;

    /**
     * Rule to enforce newlines between operands of ternary expressions.
     *
     * @since 3.1.0
     * @see https://eslint.org/docs/rules/multiline-ternary
     */
    "multiline-ternary": Linter.RuleEntry<["always" | "always-multiline" | "never"]>;

    /**
     * Rule to require constructor names to begin with a capital letter.
     *
     * @since 0.0.3-0
     * @see https://eslint.org/docs/rules/new-cap
     */
    "new-cap": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default true
                 */
                newIsCap: boolean;
                /**
                 * @default true
                 */
                capIsNew: boolean;
                newIsCapExceptions: string[];
                newIsCapExceptionPattern: string;
                capIsNewExceptions: string[];
                capIsNewExceptionPattern: string;
                /**
                 * @default true
                 */
                properties: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce or disallow parentheses when invoking a constructor with no arguments.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/new-parens
     */
    "new-parens": Linter.RuleEntry<["always" | "never"]>;

    /**
     * Rule to require a newline after each call in a method chain.
     *
     * @since 2.0.0-rc.0
     * @see https://eslint.org/docs/rules/newline-per-chained-call
     */
    "newline-per-chained-call": Linter.RuleEntry<
        [
            {
                /**
                 * @default 2
                 */
                ignoreChainWithDepth: number;
            },
        ]
    >;

    /**
     * Rule to disallow `Array` constructors.
     *
     * @since 0.4.0
     * @see https://eslint.org/docs/rules/no-array-constructor
     */
    "no-array-constructor": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow bitwise operators.
     *
     * @since 0.0.2
     * @see https://eslint.org/docs/rules/no-bitwise
     */
    "no-bitwise": Linter.RuleEntry<
        [
            Partial<{
                allow: string[];
                /**
                 * @default false
                 */
                int32Hint: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow `continue` statements.
     *
     * @since 0.19.0
     * @see https://eslint.org/docs/rules/no-continue
     */
    "no-continue": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow inline comments after code.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/no-inline-comments
     */
    "no-inline-comments": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow `if` statements as the only statement in `else` blocks.
     *
     * @since 0.6.0
     * @see https://eslint.org/docs/rules/no-lonely-if
     */
    "no-lonely-if": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow mixed binary operators.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/no-mixed-operators
     */
    "no-mixed-operators": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default
                 * [
                 *     ["+", "-", "*", "/", "%", "**"],
                 *     ["&", "|", "^", "~", "<<", ">>", ">>>"],
                 *     ["==", "!=", "===", "!==", ">", ">=", "<", "<="],
                 *     ["&&", "||"],
                 *     ["in", "instanceof"]
                 * ]
                 */
                groups: string[][];
                /**
                 * @default true
                 */
                allowSamePrecedence: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow mixed spaces and tabs for indentation.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-mixed-spaces-and-tabs
     */
    "no-mixed-spaces-and-tabs": Linter.RuleEntry<["smart-tabs"]>;

    /**
     * Rule to disallow use of chained assignment expressions.
     *
     * @since 3.14.0
     * @see https://eslint.org/docs/rules/no-multi-assign
     */
    "no-multi-assign": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow multiple empty lines.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/no-multiple-empty-lines
     */
    "no-multiple-empty-lines": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default 2
                 */
                max: number;
                maxEOF: number;
                maxBOF: number;
            }>
            | number,
        ]
    >;

    /**
     * Rule to disallow negated conditions.
     *
     * @since 1.6.0
     * @see https://eslint.org/docs/rules/no-negated-condition
     */
    "no-negated-condition": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow nested ternary expressions.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/no-nested-ternary
     */
    "no-nested-ternary": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow `Object` constructors.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-new-object
     */
    "no-new-object": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow the unary operators `++` and `--`.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-plusplus
     */
    "no-plusplus": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                allowForLoopAfterthoughts: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow specified syntax.
     *
     * @since 1.4.0
     * @see https://eslint.org/docs/rules/no-restricted-syntax
     */
    "no-restricted-syntax": Linter.RuleEntry<
        [
            ...Array<
                | string
                | {
                    selector: string;
                    message?: string | undefined;
                }
            >,
        ]
    >;

    /**
     * Rule to disallow all tabs.
     *
     * @since 3.2.0
     * @see https://eslint.org/docs/rules/no-tabs
     */
    "no-tabs": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                allowIndentationTabs: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow ternary operators.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-ternary
     */
    "no-ternary": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow trailing whitespace at the end of lines.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-trailing-spaces
     */
    "no-trailing-spaces": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                skipBlankLines: boolean;
                /**
                 * @default false
                 */
                ignoreComments: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow dangling underscores in identifiers.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-underscore-dangle
     */
    "no-underscore-dangle": Linter.RuleEntry<
        [
            Partial<{
                allow: string[];
                /**
                 * @default false
                 */
                allowAfterThis: boolean;
                /**
                 * @default false
                 */
                allowAfterSuper: boolean;
                /**
                 * @default false
                 */
                enforceInMethodNames: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow ternary operators when simpler alternatives exist.
     *
     * @since 0.21.0
     * @see https://eslint.org/docs/rules/no-unneeded-ternary
     */
    "no-unneeded-ternary": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default true
                 */
                defaultAssignment: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow whitespace before properties.
     *
     * @since 2.0.0-beta.1
     * @see https://eslint.org/docs/rules/no-whitespace-before-property
     */
    "no-whitespace-before-property": Linter.RuleEntry<[]>;

    /**
     * Rule to enforce the location of single-line statements.
     *
     * @since 3.17.0
     * @see https://eslint.org/docs/rules/nonblock-statement-body-position
     */
    "nonblock-statement-body-position": Linter.RuleEntry<
        [
            "beside" | "below" | "any",
            Partial<{
                overrides: Record<string, "beside" | "below" | "any">;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent line breaks inside braces.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/object-curly-newline
     */
    "object-curly-newline": Linter.RuleEntry<
        [
            | "always"
            | "never"
            | Partial<{
                /**
                 * @default false
                 */
                multiline: boolean;
                minProperties: number;
                /**
                 * @default true
                 */
                consistent: boolean;
            }>
            | Partial<
                Record<
                    "ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportDeclaration",
                    | "always"
                    | "never"
                    | Partial<{
                        /**
                         * @default false
                         */
                        multiline: boolean;
                        minProperties: number;
                        /**
                         * @default true
                         */
                        consistent: boolean;
                    }>
                >
            >,
        ]
    >;

    /**
     * Rule to enforce consistent spacing inside braces.
     *
     * @since 0.22.0
     * @see https://eslint.org/docs/rules/object-curly-spacing
     */
    "object-curly-spacing":
        | Linter.RuleEntry<
            [
                "never",
                {
                    /**
                     * @default false
                     */
                    arraysInObjects: boolean;
                    /**
                     * @default false
                     */
                    objectsInObjects: boolean;
                },
            ]
        >
        | Linter.RuleEntry<
            [
                "always",
                {
                    /**
                     * @default true
                     */
                    arraysInObjects: boolean;
                    /**
                     * @default true
                     */
                    objectsInObjects: boolean;
                },
            ]
        >;

    /**
     * Rule to enforce placing object properties on separate lines.
     *
     * @since 2.10.0
     * @see https://eslint.org/docs/rules/object-property-newline
     */
    "object-property-newline": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                allowAllPropertiesOnSameLine: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce variables to be declared either together or separately in functions.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/one-var
     */
    "one-var": Linter.RuleEntry<
        [
            | "always"
            | "never"
            | "consecutive"
            | Partial<
                {
                    /**
                     * @default false
                     */
                    separateRequires: boolean;
                } & Record<"var" | "let" | "const", "always" | "never" | "consecutive">
            >
            | Partial<Record<"initialized" | "uninitialized", "always" | "never" | "consecutive">>,
        ]
    >;

    /**
     * Rule to require or disallow newlines around variable declarations.
     *
     * @since 2.0.0-beta.3
     * @see https://eslint.org/docs/rules/one-var-declaration-per-line
     */
    "one-var-declaration-per-line": Linter.RuleEntry<["initializations" | "always"]>;

    /**
     * Rule to require or disallow assignment operator shorthand where possible.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/operator-assignment
     */
    "operator-assignment": Linter.RuleEntry<["always" | "never"]>;

    /**
     * Rule to enforce consistent linebreak style for operators.
     *
     * @since 0.19.0
     * @see https://eslint.org/docs/rules/operator-linebreak
     */
    "operator-linebreak": Linter.RuleEntry<
        [
            "after" | "before" | "none",
            Partial<{
                overrides: Record<string, "after" | "before" | "none">;
            }>,
        ]
    >;

    /**
     * Rule to require or disallow padding within blocks.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/padded-blocks
     */
    "padded-blocks": Linter.RuleEntry<
        [
            "always" | "never" | Partial<Record<"blocks" | "classes" | "switches", "always" | "never">>,
            {
                /**
                 * @default false
                 */
                allowSingleLineBlocks: boolean;
            },
        ]
    >;

    /**
     * Rule to require or disallow padding lines between statements.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/padding-line-between-statements
     */
    "padding-line-between-statements": Linter.RuleEntry<
        [
            ...Array<
                {
                    blankLine: "any" | "never" | "always";
                } & Record<"prev" | "next", string | string[]>
            >,
        ]
    >;

    /**
     * Rule to disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.
     *
     * @since 5.0.0-alpha.3
     * @see https://eslint.org/docs/rules/prefer-object-spread
     */
    "prefer-object-spread": Linter.RuleEntry<[]>;

    /**
     * Rule to require quotes around object literal property names.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/quote-props
     */
    "quote-props":
        | Linter.RuleEntry<["always" | "consistent"]>
        | Linter.RuleEntry<
            [
                "as-needed",
                Partial<{
                    /**
                     * @default false
                     */
                    keywords: boolean;
                    /**
                     * @default true
                     */
                    unnecessary: boolean;
                    /**
                     * @default false
                     */
                    numbers: boolean;
                }>,
            ]
        >
        | Linter.RuleEntry<
            [
                "consistent-as-needed",
                Partial<{
                    /**
                     * @default false
                     */
                    keywords: boolean;
                }>,
            ]
        >;

    /**
     * Rule to enforce the consistent use of either backticks, double, or single quotes.
     *
     * @since 0.0.7
     * @see https://eslint.org/docs/rules/quotes
     */
    quotes: Linter.RuleEntry<
        [
            "double" | "single" | "backtick",
            Partial<{
                /**
                 * @default false
                 */
                avoidEscape: boolean;
                /**
                 * @default false
                 */
                allowTemplateLiterals: boolean;
            }>,
        ]
    >;

    /**
     * Rule to require or disallow semicolons instead of ASI.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/semi
     */
    semi:
        | Linter.RuleEntry<
            [
                "always",
                Partial<{
                    /**
                     * @default false
                     */
                    omitLastInOneLineBlock: boolean;
                }>,
            ]
        >
        | Linter.RuleEntry<
            [
                "never",
                Partial<{
                    /**
                     * @default 'any'
                     */
                    beforeStatementContinuationChars: "any" | "always" | "never";
                }>,
            ]
        >;

    /**
     * Rule to enforce consistent spacing before and after semicolons.
     *
     * @since 0.16.0
     * @see https://eslint.org/docs/rules/semi-spacing
     */
    "semi-spacing": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                before: boolean;
                /**
                 * @default true
                 */
                after: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce location of semicolons.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/semi-style
     */
    "semi-style": Linter.RuleEntry<["last" | "first"]>;

    /**
     * Rule to require object keys to be sorted.
     *
     * @since 3.3.0
     * @see https://eslint.org/docs/rules/sort-keys
     */
    "sort-keys": Linter.RuleEntry<
        [
            "asc" | "desc",
            Partial<{
                /**
                 * @default true
                 */
                caseSensitive: boolean;
                /**
                 * @default 2
                 */
                minKeys: number;
                /**
                 * @default false
                 */
                natural: boolean;
                /**
                 * @default false
                 */
                allowLineSeparatedGroups: boolean;
            }>,
        ]
    >;

    /**
     * Rule to require variables within the same declaration block to be sorted.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/sort-vars
     */
    "sort-vars": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                ignoreCase: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent spacing before blocks.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/space-before-blocks
     */
    "space-before-blocks": Linter.RuleEntry<
        ["always" | "never" | Partial<Record<"functions" | "keywords" | "classes", "always" | "never" | "off">>]
    >;

    /**
     * Rule to enforce consistent spacing before `function` definition opening parenthesis.
     *
     * @since 0.18.0
     * @see https://eslint.org/docs/rules/space-before-function-paren
     */
    "space-before-function-paren": Linter.RuleEntry<
        ["always" | "never" | Partial<Record<"anonymous" | "named" | "asyncArrow", "always" | "never" | "ignore">>]
    >;

    /**
     * Rule to enforce consistent spacing inside parentheses.
     *
     * @since 0.8.0
     * @see https://eslint.org/docs/rules/space-in-parens
     */
    "space-in-parens": Linter.RuleEntry<
        [
            "never" | "always",
            Partial<{
                exceptions: string[];
            }>,
        ]
    >;

    /**
     * Rule to require spacing around infix operators.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/space-infix-ops
     */
    "space-infix-ops": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                int32Hint: boolean;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent spacing before or after unary operators.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/space-unary-ops
     */
    "space-unary-ops": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default true
                 */
                words: boolean;
                /**
                 * @default false
                 */
                nonwords: boolean;
                overrides: Record<string, boolean>;
            }>,
        ]
    >;

    /**
     * Rule to enforce consistent spacing after the `//` or `/*` in a comment.
     *
     * @since 0.23.0
     * @see https://eslint.org/docs/rules/spaced-comment
     */
    "spaced-comment": Linter.RuleEntry<
        [
            "always" | "never",
            {
                exceptions: string[];
                markers: string[];
                line: {
                    exceptions: string[];
                    markers: string[];
                };
                block: {
                    exceptions: string[];
                    markers: string[];
                    /**
                     * @default false
                     */
                    balanced: boolean;
                };
            },
        ]
    >;

    /**
     * Rule to enforce spacing around colons of switch statements.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/switch-colon-spacing
     */
    "switch-colon-spacing": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                before: boolean;
                /**
                 * @default true
                 */
                after: boolean;
            }>,
        ]
    >;

    /**
     * Rule to require or disallow spacing between template tags and their literals.
     *
     * @since 3.15.0
     * @see https://eslint.org/docs/rules/template-tag-spacing
     */
    "template-tag-spacing": Linter.RuleEntry<["never" | "always"]>;

    /**
     * Rule to require or disallow Unicode byte order mark (BOM).
     *
     * @since 2.11.0
     * @see https://eslint.org/docs/rules/unicode-bom
     */
    "unicode-bom": Linter.RuleEntry<["never" | "always"]>;

    /**
     * Rule to require parenthesis around regex literals.
     *
     * @since 0.1.0
     * @see https://eslint.org/docs/rules/wrap-regex
     */
    "wrap-regex": Linter.RuleEntry<[]>;
}


code:
import { Linter } from "../index";

export interface Variables extends Linter.RulesRecord {
    /**
     * Rule to require or disallow initialization in variable declarations.
     *
     * @since 1.0.0-rc-1
     * @see https://eslint.org/docs/rules/init-declarations
     */
    "init-declarations":
        | Linter.RuleEntry<["always"]>
        | Linter.RuleEntry<
            [
                "never",
                Partial<{
                    ignoreForLoopInit: boolean;
                }>,
            ]
        >;

    /**
     * Rule to disallow deleting variables.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-delete-var
     */
    "no-delete-var": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow labels that share a name with a variable.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-label-var
     */
    "no-label-var": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow specified global variables.
     *
     * @since 2.3.0
     * @see https://eslint.org/docs/rules/no-restricted-globals
     */
    "no-restricted-globals": Linter.RuleEntry<
        [
            ...Array<
                | string
                | {
                    name: string;
                    message?: string | undefined;
                }
            >,
        ]
    >;

    /**
     * Rule to disallow variable declarations from shadowing variables declared in the outer scope.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-shadow
     */
    "no-shadow": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                builtinGlobals: boolean;
                /**
                 * @default 'functions'
                 */
                hoist: "functions" | "all" | "never";
                allow: string[];
            }>,
        ]
    >;

    /**
     * Rule to disallow identifiers from shadowing restricted names.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.1.4
     * @see https://eslint.org/docs/rules/no-shadow-restricted-names
     */
    "no-shadow-restricted-names": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow the use of undeclared variables unless mentioned in `global` comments.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-undef
     */
    "no-undef": Linter.RuleEntry<
        [
            Partial<{
                /**
                 * @default false
                 */
                typeof: boolean;
            }>,
        ]
    >;

    /**
     * Rule to disallow initializing variables to `undefined`.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/no-undef-init
     */
    "no-undef-init": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow the use of `undefined` as an identifier.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-undefined
     */
    "no-undefined": Linter.RuleEntry<[]>;

    /**
     * Rule to disallow unused variables.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-unused-vars
     */
    "no-unused-vars": Linter.RuleEntry<
        [
            | "all"
            | "local"
            | Partial<{
                /**
                 * @default 'all'
                 */
                vars: "all" | "local";
                varsIgnorePattern: string;
                /**
                 * @default 'after-used'
                 */
                args: "after-used" | "all" | "none";
                /**
                 * @default false
                 */
                ignoreRestSiblings: boolean;
                argsIgnorePattern: string;
                /**
                 * @default 'none'
                 */
                caughtErrors: "none" | "all";
                caughtErrorsIgnorePattern: string;
                destructuredArrayIgnorePattern: string;
            }>,
        ]
    >;

    /**
     * Rule to disallow the use of variables before they are defined.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-use-before-define
     */
    "no-use-before-define": Linter.RuleEntry<
        [
            | Partial<{
                /**
                 * @default true
                 */
                functions: boolean;
                /**
                 * @default true
                 */
                classes: boolean;
                /**
                 * @default true
                 */
                variables: boolean;
                /**
                 * @default false
                 */
                allowNamedExports: boolean;
            }>
            | "nofunc",
        ]
    >;
}

license: mit


code:
/** @deprecated */
export const builtinRules: Map<string, import("./index.js").Rule.RuleModule>;
/** @deprecated */
export class FileEnumerator {
    constructor(
        params?: {
            cwd?: string;
            configArrayFactory?: any;
            extensions?: any;
            globInputPaths?: boolean;
            errorOnUnmatchedPattern?: boolean;
            ignore?: boolean;
        },
    );
    isTargetPath(filePath: string, providedConfig?: any): boolean;
    iterateFiles(
        patternOrPatterns: string | string[],
    ): IterableIterator<{ config: any; filePath: string; ignored: boolean }>;
}


code:
# Installation
> `npm install --save @types/estree`

# Summary
This package contains type definitions for estree (https://github.com/estree/estree).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree.

### Additional Details
 * Last updated: Mon, 06 Nov 2023 22:41:05 GMT
 * Dependencies: none

# Credits
These definitions were written by [RReverser](https://github.com/RReverser).


code:
declare namespace ESTree {
    interface FlowTypeAnnotation extends Node {}

    interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}

    interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}

    interface FlowDeclaration extends Declaration {}

    interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface ArrayTypeAnnotation extends FlowTypeAnnotation {
        elementType: FlowTypeAnnotation;
    }

    interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}

    interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface ClassImplements extends Node {
        id: Identifier;
        typeParameters?: TypeParameterInstantiation | null;
    }

    interface ClassProperty {
        key: Expression;
        value?: Expression | null;
        typeAnnotation?: TypeAnnotation | null;
        computed: boolean;
        static: boolean;
    }

    interface DeclareClass extends FlowDeclaration {
        id: Identifier;
        typeParameters?: TypeParameterDeclaration | null;
        body: ObjectTypeAnnotation;
        extends: InterfaceExtends[];
    }

    interface DeclareFunction extends FlowDeclaration {
        id: Identifier;
    }

    interface DeclareModule extends FlowDeclaration {
        id: Literal | Identifier;
        body: BlockStatement;
    }

    interface DeclareVariable extends FlowDeclaration {
        id: Identifier;
    }

    interface FunctionTypeAnnotation extends FlowTypeAnnotation {
        params: FunctionTypeParam[];
        returnType: FlowTypeAnnotation;
        rest?: FunctionTypeParam | null;
        typeParameters?: TypeParameterDeclaration | null;
    }

    interface FunctionTypeParam {
        name: Identifier;
        typeAnnotation: FlowTypeAnnotation;
        optional: boolean;
    }

    interface GenericTypeAnnotation extends FlowTypeAnnotation {
        id: Identifier | QualifiedTypeIdentifier;
        typeParameters?: TypeParameterInstantiation | null;
    }

    interface InterfaceExtends extends Node {
        id: Identifier | QualifiedTypeIdentifier;
        typeParameters?: TypeParameterInstantiation | null;
    }

    interface InterfaceDeclaration extends FlowDeclaration {
        id: Identifier;
        typeParameters?: TypeParameterDeclaration | null;
        extends: InterfaceExtends[];
        body: ObjectTypeAnnotation;
    }

    interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
        types: FlowTypeAnnotation[];
    }

    interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface NullableTypeAnnotation extends FlowTypeAnnotation {
        typeAnnotation: TypeAnnotation;
    }

    interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}

    interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}

    interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface TupleTypeAnnotation extends FlowTypeAnnotation {
        types: FlowTypeAnnotation[];
    }

    interface TypeofTypeAnnotation extends FlowTypeAnnotation {
        argument: FlowTypeAnnotation;
    }

    interface TypeAlias extends FlowDeclaration {
        id: Identifier;
        typeParameters?: TypeParameterDeclaration | null;
        right: FlowTypeAnnotation;
    }

    interface TypeAnnotation extends Node {
        typeAnnotation: FlowTypeAnnotation;
    }

    interface TypeCastExpression extends Expression {
        expression: Expression;
        typeAnnotation: TypeAnnotation;
    }

    interface TypeParameterDeclaration extends Node {
        params: Identifier[];
    }

    interface TypeParameterInstantiation extends Node {
        params: FlowTypeAnnotation[];
    }

    interface ObjectTypeAnnotation extends FlowTypeAnnotation {
        properties: ObjectTypeProperty[];
        indexers: ObjectTypeIndexer[];
        callProperties: ObjectTypeCallProperty[];
    }

    interface ObjectTypeCallProperty extends Node {
        value: FunctionTypeAnnotation;
        static: boolean;
    }

    interface ObjectTypeIndexer extends Node {
        id: Identifier;
        key: FlowTypeAnnotation;
        value: FlowTypeAnnotation;
        static: boolean;
    }

    interface ObjectTypeProperty extends Node {
        key: Expression;
        value: FlowTypeAnnotation;
        optional: boolean;
        static: boolean;
    }

    interface QualifiedTypeIdentifier extends Node {
        qualification: Identifier | QualifiedTypeIdentifier;
        id: Identifier;
    }

    interface UnionTypeAnnotation extends FlowTypeAnnotation {
        types: FlowTypeAnnotation[];
    }

    interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
}


code:
// This definition file follows a somewhat unusual format. ESTree allows
// runtime type checks based on the `type` parameter. In order to explain this
// to typescript we want to use discriminated union types:
// https://github.com/Microsoft/TypeScript/pull/9163
//
// For ESTree this is a bit tricky because the high level interfaces like
// Node or Function are pulling double duty. We want to pass common fields down
// to the interfaces that extend them (like Identifier or
// ArrowFunctionExpression), but you can't extend a type union or enforce
// common fields on them. So we've split the high level interfaces into two
// types, a base type which passes down inherited fields, and a type union of
// all types which extend the base type. Only the type union is exported, and
// the union is how other types refer to the collection of inheriting types.
//
// This makes the definitions file here somewhat more difficult to maintain,
// but it has the notable advantage of making ESTree much easier to use as
// an end user.

export interface BaseNodeWithoutComments {
    // Every leaf interface that extends BaseNode must specify a type property.
    // The type property should be a string literal. For example, Identifier
    // has: `type: "Identifier"`
    type: string;
    loc?: SourceLocation | null | undefined;
    range?: [number, number] | undefined;
}

export interface BaseNode extends BaseNodeWithoutComments {
    leadingComments?: Comment[] | undefined;
    trailingComments?: Comment[] | undefined;
}

export interface NodeMap {
    AssignmentProperty: AssignmentProperty;
    CatchClause: CatchClause;
    Class: Class;
    ClassBody: ClassBody;
    Expression: Expression;
    Function: Function;
    Identifier: Identifier;
    Literal: Literal;
    MethodDefinition: MethodDefinition;
    ModuleDeclaration: ModuleDeclaration;
    ModuleSpecifier: ModuleSpecifier;
    Pattern: Pattern;
    PrivateIdentifier: PrivateIdentifier;
    Program: Program;
    Property: Property;
    PropertyDefinition: PropertyDefinition;
    SpreadElement: SpreadElement;
    Statement: Statement;
    Super: Super;
    SwitchCase: SwitchCase;
    TemplateElement: TemplateElement;
    VariableDeclarator: VariableDeclarator;
}

export type Node = NodeMap[keyof NodeMap];

export interface Comment extends BaseNodeWithoutComments {
    type: "Line" | "Block";
    value: string;
}

export interface SourceLocation {
    source?: string | null | undefined;
    start: Position;
    end: Position;
}

export interface Position {
    /** >= 1 */
    line: number;
    /** >= 0 */
    column: number;
}

export interface Program extends BaseNode {
    type: "Program";
    sourceType: "script" | "module";
    body: Array<Directive | Statement | ModuleDeclaration>;
    comments?: Comment[] | undefined;
}

export interface Directive extends BaseNode {
    type: "ExpressionStatement";
    expression: Literal;
    directive: string;
}

export interface BaseFunction extends BaseNode {
    params: Pattern[];
    generator?: boolean | undefined;
    async?: boolean | undefined;
    // The body is either BlockStatement or Expression because arrow functions
    // can have a body that's either. FunctionDeclarations and
    // FunctionExpressions have only BlockStatement bodies.
    body: BlockStatement | Expression;
}

export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;

export type Statement =
    | ExpressionStatement
    | BlockStatement
    | StaticBlock
    | EmptyStatement
    | DebuggerStatement
    | WithStatement
    | ReturnStatement
    | LabeledStatement
    | BreakStatement
    | ContinueStatement
    | IfStatement
    | SwitchStatement
    | ThrowStatement
    | TryStatement
    | WhileStatement
    | DoWhileStatement
    | ForStatement
    | ForInStatement
    | ForOfStatement
    | Declaration;

export interface BaseStatement extends BaseNode {}

export interface EmptyStatement extends BaseStatement {
    type: "EmptyStatement";
}

export interface BlockStatement extends BaseStatement {
    type: "BlockStatement";
    body: Statement[];
    innerComments?: Comment[] | undefined;
}

export interface StaticBlock extends Omit<BlockStatement, "type"> {
    type: "StaticBlock";
}

export interface ExpressionStatement extends BaseStatement {
    type: "ExpressionStatement";
    expression: Expression;
}

export interface IfStatement extends BaseStatement {
    type: "IfStatement";
    test: Expression;
    consequent: Statement;
    alternate?: Statement | null | undefined;
}

export interface LabeledStatement extends BaseStatement {
    type: "LabeledStatement";
    label: Identifier;
    body: Statement;
}

export interface BreakStatement extends BaseStatement {
    type: "BreakStatement";
    label?: Identifier | null | undefined;
}

export interface ContinueStatement extends BaseStatement {
    type: "ContinueStatement";
    label?: Identifier | null | undefined;
}

export interface WithStatement extends BaseStatement {
    type: "WithStatement";
    object: Expression;
    body: Statement;
}

export interface SwitchStatement extends BaseStatement {
    type: "SwitchStatement";
    discriminant: Expression;
    cases: SwitchCase[];
}

export interface ReturnStatement extends BaseStatement {
    type: "ReturnStatement";
    argument?: Expression | null | undefined;
}

export interface ThrowStatement extends BaseStatement {
    type: "ThrowStatement";
    argument: Expression;
}

export interface TryStatement extends BaseStatement {
    type: "TryStatement";
    block: BlockStatement;
    handler?: CatchClause | null | undefined;
    finalizer?: BlockStatement | null | undefined;
}

export interface WhileStatement extends BaseStatement {
    type: "WhileStatement";
    test: Expression;
    body: Statement;
}

export interface DoWhileStatement extends BaseStatement {
    type: "DoWhileStatement";
    body: Statement;
    test: Expression;
}

export interface ForStatement extends BaseStatement {
    type: "ForStatement";
    init?: VariableDeclaration | Expression | null | undefined;
    test?: Expression | null | undefined;
    update?: Expression | null | undefined;
    body: Statement;
}

export interface BaseForXStatement extends BaseStatement {
    left: VariableDeclaration | Pattern;
    right: Expression;
    body: Statement;
}

export interface ForInStatement extends BaseForXStatement {
    type: "ForInStatement";
}

export interface DebuggerStatement extends BaseStatement {
    type: "DebuggerStatement";
}

export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;

export interface BaseDeclaration extends BaseStatement {}

export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
    type: "FunctionDeclaration";
    /** It is null when a function declaration is a part of the `export default function` statement */
    id: Identifier | null;
    body: BlockStatement;
}

export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
    id: Identifier;
}

export interface VariableDeclaration extends BaseDeclaration {
    type: "VariableDeclaration";
    declarations: VariableDeclarator[];
    kind: "var" | "let" | "const";
}

export interface VariableDeclarator extends BaseNode {
    type: "VariableDeclarator";
    id: Pattern;
    init?: Expression | null | undefined;
}

export interface ExpressionMap {
    ArrayExpression: ArrayExpression;
    ArrowFunctionExpression: ArrowFunctionExpression;
    AssignmentExpression: AssignmentExpression;
    AwaitExpression: AwaitExpression;
    BinaryExpression: BinaryExpression;
    CallExpression: CallExpression;
    ChainExpression: ChainExpression;
    ClassExpression: ClassExpression;
    ConditionalExpression: ConditionalExpression;
    FunctionExpression: FunctionExpression;
    Identifier: Identifier;
    ImportExpression: ImportExpression;
    Literal: Literal;
    LogicalExpression: LogicalExpression;
    MemberExpression: MemberExpression;
    MetaProperty: MetaProperty;
    NewExpression: NewExpression;
    ObjectExpression: ObjectExpression;
    SequenceExpression: SequenceExpression;
    TaggedTemplateExpression: TaggedTemplateExpression;
    TemplateLiteral: TemplateLiteral;
    ThisExpression: ThisExpression;
    UnaryExpression: UnaryExpression;
    UpdateExpression: UpdateExpression;
    YieldExpression: YieldExpression;
}

export type Expression = ExpressionMap[keyof ExpressionMap];

export interface BaseExpression extends BaseNode {}

export type ChainElement = SimpleCallExpression | MemberExpression;

export interface ChainExpression extends BaseExpression {
    type: "ChainExpression";
    expression: ChainElement;
}

export interface ThisExpression extends BaseExpression {
    type: "ThisExpression";
}

export interface ArrayExpression extends BaseExpression {
    type: "ArrayExpression";
    elements: Array<Expression | SpreadElement | null>;
}

export interface ObjectExpression extends BaseExpression {
    type: "ObjectExpression";
    properties: Array<Property | SpreadElement>;
}

export interface PrivateIdentifier extends BaseNode {
    type: "PrivateIdentifier";
    name: string;
}

export interface Property extends BaseNode {
    type: "Property";
    key: Expression | PrivateIdentifier;
    value: Expression | Pattern; // Could be an AssignmentProperty
    kind: "init" | "get" | "set";
    method: boolean;
    shorthand: boolean;
    computed: boolean;
}

export interface PropertyDefinition extends BaseNode {
    type: "PropertyDefinition";
    key: Expression | PrivateIdentifier;
    value?: Expression | null | undefined;
    computed: boolean;
    static: boolean;
}

export interface FunctionExpression extends BaseFunction, BaseExpression {
    id?: Identifier | null | undefined;
    type: "FunctionExpression";
    body: BlockStatement;
}

export interface SequenceExpression extends BaseExpression {
    type: "SequenceExpression";
    expressions: Expression[];
}

export interface UnaryExpression extends BaseExpression {
    type: "UnaryExpression";
    operator: UnaryOperator;
    prefix: true;
    argument: Expression;
}

export interface BinaryExpression extends BaseExpression {
    type: "BinaryExpression";
    operator: BinaryOperator;
    left: Expression;
    right: Expression;
}

export interface AssignmentExpression extends BaseExpression {
    type: "AssignmentExpression";
    operator: AssignmentOperator;
    left: Pattern | MemberExpression;
    right: Expression;
}

export interface UpdateExpression extends BaseExpression {
    type: "UpdateExpression";
    operator: UpdateOperator;
    argument: Expression;
    prefix: boolean;
}

export interface LogicalExpression extends BaseExpression {
    type: "LogicalExpression";
    operator: LogicalOperator;
    left: Expression;
    right: Expression;
}

export interface ConditionalExpression extends BaseExpression {
    type: "ConditionalExpression";
    test: Expression;
    alternate: Expression;
    consequent: Expression;
}

export interface BaseCallExpression extends BaseExpression {
    callee: Expression | Super;
    arguments: Array<Expression | SpreadElement>;
}
export type CallExpression = SimpleCallExpression | NewExpression;

export interface SimpleCallExpression extends BaseCallExpression {
    type: "CallExpression";
    optional: boolean;
}

export interface NewExpression extends BaseCallExpression {
    type: "NewExpression";
}

export interface MemberExpression extends BaseExpression, BasePattern {
    type: "MemberExpression";
    object: Expression | Super;
    property: Expression | PrivateIdentifier;
    computed: boolean;
    optional: boolean;
}

export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;

export interface BasePattern extends BaseNode {}

export interface SwitchCase extends BaseNode {
    type: "SwitchCase";
    test?: Expression | null | undefined;
    consequent: Statement[];
}

export interface CatchClause extends BaseNode {
    type: "CatchClause";
    param: Pattern | null;
    body: BlockStatement;
}

export interface Identifier extends BaseNode, BaseExpression, BasePattern {
    type: "Identifier";
    name: string;
}

export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;

export interface SimpleLiteral extends BaseNode, BaseExpression {
    type: "Literal";
    value: string | boolean | number | null;
    raw?: string | undefined;
}

export interface RegExpLiteral extends BaseNode, BaseExpression {
    type: "Literal";
    value?: RegExp | null | undefined;
    regex: {
        pattern: string;
        flags: string;
    };
    raw?: string | undefined;
}

export interface BigIntLiteral extends BaseNode, BaseExpression {
    type: "Literal";
    value?: bigint | null | undefined;
    bigint: string;
    raw?: string | undefined;
}

export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";

export type BinaryOperator =
    | "=="
    | "!="
    | "==="
    | "!=="
    | "<"
    | "<="
    | ">"
    | ">="
    | "<<"
    | ">>"
    | ">>>"
    | "+"
    | "-"
    | "*"
    | "/"
    | "%"
    | "**"
    | "|"
    | "^"
    | "&"
    | "in"
    | "instanceof";

export type LogicalOperator = "||" | "&&" | "??";

export type AssignmentOperator =
    | "="
    | "+="
    | "-="
    | "*="
    | "/="
    | "%="
    | "**="
    | "<<="
    | ">>="
    | ">>>="
    | "|="
    | "^="
    | "&="
    | "||="
    | "&&="
    | "??=";

export type UpdateOperator = "++" | "--";

export interface ForOfStatement extends BaseForXStatement {
    type: "ForOfStatement";
    await: boolean;
}

export interface Super extends BaseNode {
    type: "Super";
}

export interface SpreadElement extends BaseNode {
    type: "SpreadElement";
    argument: Expression;
}

export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
    type: "ArrowFunctionExpression";
    expression: boolean;
    body: BlockStatement | Expression;
}

export interface YieldExpression extends BaseExpression {
    type: "YieldExpression";
    argument?: Expression | null | undefined;
    delegate: boolean;
}

export interface TemplateLiteral extends BaseExpression {
    type: "TemplateLiteral";
    quasis: TemplateElement[];
    expressions: Expression[];
}

export interface TaggedTemplateExpression extends BaseExpression {
    type: "TaggedTemplateExpression";
    tag: Expression;
    quasi: TemplateLiteral;
}

export interface TemplateElement extends BaseNode {
    type: "TemplateElement";
    tail: boolean;
    value: {
        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
        cooked?: string | null | undefined;
        raw: string;
    };
}

export interface AssignmentProperty extends Property {
    value: Pattern;
    kind: "init";
    method: boolean; // false
}

export interface ObjectPattern extends BasePattern {
    type: "ObjectPattern";
    properties: Array<AssignmentProperty | RestElement>;
}

export interface ArrayPattern extends BasePattern {
    type: "ArrayPattern";
    elements: Array<Pattern | null>;
}

export interface RestElement extends BasePattern {
    type: "RestElement";
    argument: Pattern;
}

export interface AssignmentPattern extends BasePattern {
    type: "AssignmentPattern";
    left: Pattern;
    right: Expression;
}

export type Class = ClassDeclaration | ClassExpression;
export interface BaseClass extends BaseNode {
    superClass?: Expression | null | undefined;
    body: ClassBody;
}

export interface ClassBody extends BaseNode {
    type: "ClassBody";
    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
}

export interface MethodDefinition extends BaseNode {
    type: "MethodDefinition";
    key: Expression | PrivateIdentifier;
    value: FunctionExpression;
    kind: "constructor" | "method" | "get" | "set";
    computed: boolean;
    static: boolean;
}

export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
    type: "ClassDeclaration";
    /** It is null when a class declaration is a part of the `export default class` statement */
    id: Identifier | null;
}

export interface ClassDeclaration extends MaybeNamedClassDeclaration {
    id: Identifier;
}

export interface ClassExpression extends BaseClass, BaseExpression {
    type: "ClassExpression";
    id?: Identifier | null | undefined;
}

export interface MetaProperty extends BaseExpression {
    type: "MetaProperty";
    meta: Identifier;
    property: Identifier;
}

export type ModuleDeclaration =
    | ImportDeclaration
    | ExportNamedDeclaration
    | ExportDefaultDeclaration
    | ExportAllDeclaration;
export interface BaseModuleDeclaration extends BaseNode {}

export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
export interface BaseModuleSpecifier extends BaseNode {
    local: Identifier;
}

export interface ImportDeclaration extends BaseModuleDeclaration {
    type: "ImportDeclaration";
    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
    source: Literal;
}

export interface ImportSpecifier extends BaseModuleSpecifier {
    type: "ImportSpecifier";
    imported: Identifier;
}

export interface ImportExpression extends BaseExpression {
    type: "ImportExpression";
    source: Expression;
}

export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
    type: "ImportDefaultSpecifier";
}

export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
    type: "ImportNamespaceSpecifier";
}

export interface ExportNamedDeclaration extends BaseModuleDeclaration {
    type: "ExportNamedDeclaration";
    declaration?: Declaration | null | undefined;
    specifiers: ExportSpecifier[];
    source?: Literal | null | undefined;
}

export interface ExportSpecifier extends BaseModuleSpecifier {
    type: "ExportSpecifier";
    exported: Identifier;
}

export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
    type: "ExportDefaultDeclaration";
    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
}

export interface ExportAllDeclaration extends BaseModuleDeclaration {
    type: "ExportAllDeclaration";
    exported: Identifier | null;
    source: Literal;
}

export interface AwaitExpression extends BaseExpression {
    type: "AwaitExpression";
    argument: Expression;
}


@types/estree

description: TypeScript definitions for estree

license: MIT

RReverser

githubUsername: RReverser

type: git

directory: types/estree


code:
# Installation
> `npm install --save @types/express-serve-static-core`

# Summary
This package contains type definitions for express-serve-static-core (http://expressjs.com).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express-serve-static-core.

### Additional Details
 * Last updated: Wed, 19 Jun 2024 19:07:05 GMT
 * Dependencies: [@types/node](https://npmjs.com/package/@types/node), [@types/qs](https://npmjs.com/package/@types/qs), [@types/range-parser](https://npmjs.com/package/@types/range-parser), [@types/send](https://npmjs.com/package/@types/send)

# Credits
These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Satana Charuwichitratana](https://github.com/micksatana), [Jose Luis Leon](https://github.com/JoseLion), [David Stephens](https://github.com/dwrss), and [Shin Ando](https://github.com/andoshin11).