import selectorParser from "postcss-selector-parser";
import * as _$vue_eslint_parser0 from "vue-eslint-parser";
import { AST as AST$1 } from "vue-eslint-parser";
import * as _$eslint from "eslint";

//#region node_modules/@types/estree/index.d.ts
// 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.
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$1 | null | undefined;
  range?: [number, number] | undefined;
}
interface BaseNode extends BaseNodeWithoutComments {
  leadingComments?: Comment[] | undefined;
  trailingComments?: Comment[] | undefined;
}
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;
}
type Node = NodeMap[keyof NodeMap];
interface Comment extends BaseNodeWithoutComments {
  type: "Line" | "Block";
  value: string;
}
interface SourceLocation$1 {
  source?: string | null | undefined;
  start: Position;
  end: Position;
}
interface Position {
  /** >= 1 */
  line: number;
  /** >= 0 */
  column: number;
}
interface Program extends BaseNode {
  type: "Program";
  sourceType: "script" | "module";
  body: Array<Directive | Statement | ModuleDeclaration>;
  comments?: Comment[] | undefined;
}
interface Directive extends BaseNode {
  type: "ExpressionStatement";
  expression: Literal;
  directive: string;
}
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;
}
type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
interface BaseStatement extends BaseNode {}
interface EmptyStatement extends BaseStatement {
  type: "EmptyStatement";
}
interface BlockStatement extends BaseStatement {
  type: "BlockStatement";
  body: Statement[];
  innerComments?: Comment[] | undefined;
}
interface StaticBlock extends Omit<BlockStatement, "type"> {
  type: "StaticBlock";
}
interface ExpressionStatement extends BaseStatement {
  type: "ExpressionStatement";
  expression: Expression;
}
interface IfStatement extends BaseStatement {
  type: "IfStatement";
  test: Expression;
  consequent: Statement;
  alternate?: Statement | null | undefined;
}
interface LabeledStatement extends BaseStatement {
  type: "LabeledStatement";
  label: Identifier;
  body: Statement;
}
interface BreakStatement extends BaseStatement {
  type: "BreakStatement";
  label?: Identifier | null | undefined;
}
interface ContinueStatement extends BaseStatement {
  type: "ContinueStatement";
  label?: Identifier | null | undefined;
}
interface WithStatement extends BaseStatement {
  type: "WithStatement";
  object: Expression;
  body: Statement;
}
interface SwitchStatement extends BaseStatement {
  type: "SwitchStatement";
  discriminant: Expression;
  cases: SwitchCase[];
}
interface ReturnStatement extends BaseStatement {
  type: "ReturnStatement";
  argument?: Expression | null | undefined;
}
interface ThrowStatement extends BaseStatement {
  type: "ThrowStatement";
  argument: Expression;
}
interface TryStatement extends BaseStatement {
  type: "TryStatement";
  block: BlockStatement;
  handler?: CatchClause | null | undefined;
  finalizer?: BlockStatement | null | undefined;
}
interface WhileStatement extends BaseStatement {
  type: "WhileStatement";
  test: Expression;
  body: Statement;
}
interface DoWhileStatement extends BaseStatement {
  type: "DoWhileStatement";
  body: Statement;
  test: Expression;
}
interface ForStatement extends BaseStatement {
  type: "ForStatement";
  init?: VariableDeclaration | Expression | null | undefined;
  test?: Expression | null | undefined;
  update?: Expression | null | undefined;
  body: Statement;
}
interface BaseForXStatement extends BaseStatement {
  left: VariableDeclaration | Pattern;
  right: Expression;
  body: Statement;
}
interface ForInStatement extends BaseForXStatement {
  type: "ForInStatement";
}
interface DebuggerStatement extends BaseStatement {
  type: "DebuggerStatement";
}
type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
interface BaseDeclaration extends BaseStatement {}
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;
}
interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
  id: Identifier;
}
interface VariableDeclaration extends BaseDeclaration {
  type: "VariableDeclaration";
  declarations: VariableDeclarator[];
  kind: "var" | "let" | "const" | "using" | "await using";
}
interface VariableDeclarator extends BaseNode {
  type: "VariableDeclarator";
  id: Pattern;
  init?: Expression | null | undefined;
}
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;
}
type Expression = ExpressionMap[keyof ExpressionMap];
interface BaseExpression extends BaseNode {}
type ChainElement = SimpleCallExpression | MemberExpression;
interface ChainExpression extends BaseExpression {
  type: "ChainExpression";
  expression: ChainElement;
}
interface ThisExpression extends BaseExpression {
  type: "ThisExpression";
}
interface ArrayExpression extends BaseExpression {
  type: "ArrayExpression";
  elements: Array<Expression | SpreadElement | null>;
}
interface ObjectExpression extends BaseExpression {
  type: "ObjectExpression";
  properties: Array<Property | SpreadElement>;
}
interface PrivateIdentifier extends BaseNode {
  type: "PrivateIdentifier";
  name: string;
}
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;
}
interface PropertyDefinition extends BaseNode {
  type: "PropertyDefinition";
  key: Expression | PrivateIdentifier;
  value?: Expression | null | undefined;
  computed: boolean;
  static: boolean;
}
interface FunctionExpression extends BaseFunction, BaseExpression {
  id?: Identifier | null | undefined;
  type: "FunctionExpression";
  body: BlockStatement;
}
interface SequenceExpression extends BaseExpression {
  type: "SequenceExpression";
  expressions: Expression[];
}
interface UnaryExpression extends BaseExpression {
  type: "UnaryExpression";
  operator: UnaryOperator;
  prefix: true;
  argument: Expression;
}
interface BinaryExpression extends BaseExpression {
  type: "BinaryExpression";
  operator: BinaryOperator;
  left: Expression | PrivateIdentifier;
  right: Expression;
}
interface AssignmentExpression extends BaseExpression {
  type: "AssignmentExpression";
  operator: AssignmentOperator;
  left: Pattern | MemberExpression;
  right: Expression;
}
interface UpdateExpression extends BaseExpression {
  type: "UpdateExpression";
  operator: UpdateOperator;
  argument: Expression;
  prefix: boolean;
}
interface LogicalExpression extends BaseExpression {
  type: "LogicalExpression";
  operator: LogicalOperator;
  left: Expression;
  right: Expression;
}
interface ConditionalExpression extends BaseExpression {
  type: "ConditionalExpression";
  test: Expression;
  alternate: Expression;
  consequent: Expression;
}
interface BaseCallExpression extends BaseExpression {
  callee: Expression | Super;
  arguments: Array<Expression | SpreadElement>;
}
type CallExpression = SimpleCallExpression | NewExpression;
interface SimpleCallExpression extends BaseCallExpression {
  type: "CallExpression";
  optional: boolean;
}
interface NewExpression extends BaseCallExpression {
  type: "NewExpression";
}
interface MemberExpression extends BaseExpression, BasePattern {
  type: "MemberExpression";
  object: Expression | Super;
  property: Expression | PrivateIdentifier;
  computed: boolean;
  optional: boolean;
}
type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
interface BasePattern extends BaseNode {}
interface SwitchCase extends BaseNode {
  type: "SwitchCase";
  test?: Expression | null | undefined;
  consequent: Statement[];
}
interface CatchClause extends BaseNode {
  type: "CatchClause";
  param: Pattern | null;
  body: BlockStatement;
}
interface Identifier extends BaseNode, BaseExpression, BasePattern {
  type: "Identifier";
  name: string;
}
type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
interface SimpleLiteral extends BaseNode, BaseExpression {
  type: "Literal";
  value: string | boolean | number | null;
  raw?: string | undefined;
}
interface RegExpLiteral extends BaseNode, BaseExpression {
  type: "Literal";
  value?: RegExp | null | undefined;
  regex: {
    pattern: string;
    flags: string;
  };
  raw?: string | undefined;
}
interface BigIntLiteral extends BaseNode, BaseExpression {
  type: "Literal";
  value?: bigint | null | undefined;
  bigint: string;
  raw?: string | undefined;
}
type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
type LogicalOperator = "||" | "&&" | "??";
type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
type UpdateOperator = "++" | "--";
interface ForOfStatement extends BaseForXStatement {
  type: "ForOfStatement";
  await: boolean;
}
interface Super extends BaseNode {
  type: "Super";
}
interface SpreadElement extends BaseNode {
  type: "SpreadElement";
  argument: Expression;
}
interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
  type: "ArrowFunctionExpression";
  expression: boolean;
  body: BlockStatement | Expression;
}
interface YieldExpression extends BaseExpression {
  type: "YieldExpression";
  argument?: Expression | null | undefined;
  delegate: boolean;
}
interface TemplateLiteral extends BaseExpression {
  type: "TemplateLiteral";
  quasis: TemplateElement[];
  expressions: Expression[];
}
interface TaggedTemplateExpression extends BaseExpression {
  type: "TaggedTemplateExpression";
  tag: Expression;
  quasi: TemplateLiteral;
}
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;
  };
}
interface AssignmentProperty extends Property {
  value: Pattern;
  kind: "init";
  method: boolean; // false
}
interface ObjectPattern extends BasePattern {
  type: "ObjectPattern";
  properties: Array<AssignmentProperty | RestElement>;
}
interface ArrayPattern extends BasePattern {
  type: "ArrayPattern";
  elements: Array<Pattern | null>;
}
interface RestElement extends BasePattern {
  type: "RestElement";
  argument: Pattern;
}
interface AssignmentPattern extends BasePattern {
  type: "AssignmentPattern";
  left: Pattern;
  right: Expression;
}
type Class = ClassDeclaration | ClassExpression;
interface BaseClass extends BaseNode {
  superClass?: Expression | null | undefined;
  body: ClassBody;
}
interface ClassBody extends BaseNode {
  type: "ClassBody";
  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
}
interface MethodDefinition extends BaseNode {
  type: "MethodDefinition";
  key: Expression | PrivateIdentifier;
  value: FunctionExpression;
  kind: "constructor" | "method" | "get" | "set";
  computed: boolean;
  static: boolean;
}
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;
}
interface ClassDeclaration extends MaybeNamedClassDeclaration {
  id: Identifier;
}
interface ClassExpression extends BaseClass, BaseExpression {
  type: "ClassExpression";
  id?: Identifier | null | undefined;
}
interface MetaProperty extends BaseExpression {
  type: "MetaProperty";
  meta: Identifier;
  property: Identifier;
}
type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
interface BaseModuleDeclaration extends BaseNode {}
type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
interface BaseModuleSpecifier extends BaseNode {
  local: Identifier;
}
interface ImportDeclaration extends BaseModuleDeclaration {
  type: "ImportDeclaration";
  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
  attributes: ImportAttribute[];
  source: Literal;
}
interface ImportSpecifier extends BaseModuleSpecifier {
  type: "ImportSpecifier";
  imported: Identifier | Literal;
}
interface ImportAttribute extends BaseNode {
  type: "ImportAttribute";
  key: Identifier | Literal;
  value: Literal;
}
interface ImportExpression extends BaseExpression {
  type: "ImportExpression";
  source: Expression;
  options?: Expression | null | undefined;
}
interface ImportDefaultSpecifier extends BaseModuleSpecifier {
  type: "ImportDefaultSpecifier";
}
interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
  type: "ImportNamespaceSpecifier";
}
interface ExportNamedDeclaration extends BaseModuleDeclaration {
  type: "ExportNamedDeclaration";
  declaration?: Declaration | null | undefined;
  specifiers: ExportSpecifier[];
  attributes: ImportAttribute[];
  source?: Literal | null | undefined;
}
interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
  type: "ExportSpecifier";
  local: Identifier | Literal;
  exported: Identifier | Literal;
}
interface ExportDefaultDeclaration extends BaseModuleDeclaration {
  type: "ExportDefaultDeclaration";
  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
}
interface ExportAllDeclaration extends BaseModuleDeclaration {
  type: "ExportAllDeclaration";
  exported: Identifier | Literal | null;
  attributes: ImportAttribute[];
  source: Literal;
}
interface AwaitExpression extends BaseExpression {
  type: "AwaitExpression";
  argument: Expression;
}
//#endregion
//#region typings/eslint-scope/index.d.ts
interface ScopeManager {
  scopes: Scope[];
  globalScope: Scope;
  acquire(node: Node, inner: boolean): Scope | null;
  acquireAll(node: Node): Scope[];
}
interface Scope {
  block: Node;
  childScopes: Scope[];
  directCallToEcalScope: boolean;
  dynamic: boolean;
  functionExpressionScope: boolean;
  isStrict: boolean;
  references: Reference[];
  set: Map<string, Variable>;
  taints: Map<string, boolean>;
  thisFound: boolean;
  through: Reference[];
  type: string;
  upper: Scope | null;
  variables: Variable[];
  variableScope: Scope;
}
interface Variable {
  defs: VariableDefinition[];
  identifiers: Identifier[];
  name: string;
  references: Reference[];
  scope: Scope;
  stack: boolean;
}
interface VariableDefinition {
  type: string;
  name: Identifier;
  node: Node;
  parent?: Node;
}
interface Reference {
  from: Scope;
  identifier: Identifier;
  partial: boolean;
  resolved: Variable | null;
  tainted: boolean;
  writeExpr: Expression;
  isRead(): boolean;
  isReadOnly(): boolean;
  isReadWrite(): boolean;
  isStatic(): boolean;
  isWrite(): boolean;
  isWriteOnly(): boolean;
}
//#endregion
//#region lib/types.d.ts
interface RuleListener {
  [key: string]: ((node: never) => void) | undefined;
}
type Rule = {
  create(context: RuleContext): RuleListener;
  meta: {
    docs: {
      description: string;
      categories: ("vue2-recommended" | "vue3-recommended")[];
      ruleId?: string;
      ruleName?: string;
      default?: string;
      replacedBy?: string[];
      url: string;
      suggestion?: true;
    };
    deprecated?: boolean;
    fixable?: "code" | "whitespace" | null;
    hasSuggestions?: boolean;
    schema: unknown[];
    messages: {
      [key: string]: string;
    };
    type: "suggestion" | "problem";
  };
};
type LineAndColumnData = AST$1.Location;
type SourceLocation = AST$1.LocationRange;
type Range = [number, number];
interface ParserServices {
  /**
   * Get the token store of the template body.
   * @returns The token store of template body.
   */
  getTemplateBodyTokenStore?: () => TokenStore;
  /**
   * Get the root document fragment.
   * @returns The root document fragment.
   */
  getDocumentFragment?: () => AST$1.VDocumentFragment | null;
}
interface RuleContext {
  id: string;
  sourceCode: SourceCode;
  report: (descriptor: ReportDescriptor) => void;
  options: any[];
  filename: string;
  physicalFilename: string;
  cwd: string;
  parserServices: ParserServices;
}
interface Fix {
  range: Range;
  text: string;
}
interface RuleFixer {
  insertTextAfter(nodeOrToken: any, text: string): Fix;
  insertTextAfterRange(range: Range, text: string): Fix;
  insertTextBefore(nodeOrToken: any, text: string): Fix;
  insertTextBeforeRange(range: Range, text: string): Fix;
  remove(nodeOrToken: any): Fix;
  removeRange(range: Range): Fix;
  replaceText(nodeOrToken: any, text: string): Fix;
  replaceTextRange(range: Range, text: string): Fix;
}
type ReportSuggestion = ({
  messageId: string;
} | {
  desc: string;
}) & {
  data?: {
    [key: string]: string;
  };
  fix?(fixer: RuleFixer): null | Fix | Fix[] | IterableIterator<Fix>;
};
type ReportDescriptorNodeLocation = {
  node: AST$1.HasLocation;
};
type ReportDescriptorSourceLocation = {
  loc: SourceLocation | {
    line: number;
    column: number;
  };
};
type ReportDescriptorLocation = ReportDescriptorNodeLocation | ReportDescriptorSourceLocation;
type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorOptions & Rule.ReportDescriptorMessage & {
  suggest?: ReportSuggestion[];
};
type FilterPredicate = (tokenOrComment: AST$1.Token) => boolean;
type CursorWithSkipOptions = number | FilterPredicate | {
  includeComments?: boolean;
  filter?: FilterPredicate;
  skip?: number;
};
interface SourceCode {
  text: string;
  ast: AST$1.ESLintProgram;
  lines: string[];
  hasBOM: boolean;
  visitorKeys: any;
  scopeManager: ScopeManager;
  parserServices: ParserServices;
  getAllComments: () => AST$1.Token[];
  getText(node?: AST$1.Node, beforeCount?: number, afterCount?: number): string;
  getLines(): string[];
  getNodeByRangeIndex(index: number): AST$1.ESLintNode | null;
  getLocFromIndex(index: number): LineAndColumnData;
  getIndexFromLoc(location: LineAndColumnData): number;
  getFirstToken(node: AST$1.Node, options?: CursorWithSkipOptions): AST$1.Token | null;
}
interface TokenStore {
  getFirstToken(node: AST$1.Node, options?: CursorWithSkipOptions): AST$1.Token | null;
  getLastToken(node: AST$1.Node, options?: CursorWithSkipOptions): AST$1.Token | null;
  getTokens(node: AST$1.Node, beforeCount?: number, afterCount?: number): AST$1.Token[];
  getTokenBefore(node: AST$1.Node): AST$1.Token;
  getTokenAfter(node: AST$1.Node): AST$1.Token;
}
//#endregion
//#region lib/index.d.ts
declare const _default: {
  configs: {
    base: ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    })[];
    recommended: ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    } | {
      rules: {
        [key: string]: string;
      };
      name: string;
    })[];
    "vue2-recommended": ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    } | {
      rules: {
        [key: string]: string;
      };
      name: string;
    })[];
    all: ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    } | {
      rules: {
        [key: string]: string;
      };
      name: string;
    })[]; /** @deprecated Use `base` instead. */
    "flat/base": ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    })[]; /** @deprecated Use `recommended` instead. */
    "flat/recommended": ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    } | {
      rules: {
        [key: string]: string;
      };
      name: string;
    })[]; /** @deprecated Use `vue2-recommended` instead. */
    "flat/vue2-recommended": ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    } | {
      rules: {
        [key: string]: string;
      };
      name: string;
    })[]; /** @deprecated Use `all` instead. */
    "flat/all": ({
      plugins: {
        readonly "vue-scoped-css": _$eslint.ESLint.Plugin;
      };
      name: string;
      files?: undefined;
      languageOptions?: undefined;
    } | {
      files: string[];
      languageOptions: {
        parser: typeof _$vue_eslint_parser0;
      };
      name: string;
      plugins?: undefined;
    } | {
      rules: {
        [key: string]: string;
      };
      name: string;
    })[];
  };
  rules: {
    [key: string]: Rule;
  };
};
//#endregion
export { _default as default };