//#region rules/array-bracket-newline/types.d.ts

type ArrayBracketNewlineSchema0 = ('always' | 'never' | 'consistent') | {
  multiline?: boolean;
  minItems?: number | null;
};
type ArrayBracketNewlineRuleOptions = [ArrayBracketNewlineSchema0?];
//#endregion
//#region rules/array-bracket-spacing/types.d.ts

type ArrayBracketSpacingSchema0 = 'always' | 'never';
interface ArrayBracketSpacingSchema1 {
  singleValue?: boolean;
  objectsInArrays?: boolean;
  arraysInArrays?: boolean;
}
type ArrayBracketSpacingRuleOptions = [ArrayBracketSpacingSchema0?, ArrayBracketSpacingSchema1?];
//#endregion
//#region rules/array-element-newline/types.d.ts

type ArrayElementNewlineSchema0 = [] | [BasicConfig | {
  ArrayExpression?: BasicConfig;
  ArrayPattern?: BasicConfig;
}];
type BasicConfig = ('always' | 'never' | 'consistent') | {
  consistent?: boolean;
  multiline?: boolean;
  minItems?: number | null;
};
type ArrayElementNewlineRuleOptions = ArrayElementNewlineSchema0;
//#endregion
//#region rules/arrow-parens/types.d.ts

type ArrowParensSchema0 = 'always' | 'as-needed';
interface ArrowParensSchema1 {
  requireForBlockBody?: boolean;
}
type ArrowParensRuleOptions = [ArrowParensSchema0?, ArrowParensSchema1?];
//#endregion
//#region rules/arrow-spacing/types.d.ts

interface ArrowSpacingSchema0 {
  before?: boolean;
  after?: boolean;
}
type ArrowSpacingRuleOptions = [ArrowSpacingSchema0?];
//#endregion
//#region rules/block-spacing/types.d.ts

type BlockSpacingSchema0 = 'always' | 'never';
type BlockSpacingRuleOptions = [BlockSpacingSchema0?];
//#endregion
//#region rules/brace-style/types.d.ts

type BraceStyleSchema0 = '1tbs' | 'stroustrup' | 'allman';
interface BraceStyleSchema1 {
  allowSingleLine?: boolean;
}
type BraceStyleRuleOptions = [BraceStyleSchema0?, BraceStyleSchema1?];
//#endregion
//#region rules/comma-dangle/types.d.ts

type CommaDangleSchema0 = [] | [Value | {
  arrays?: ValueWithIgnore;
  objects?: ValueWithIgnore;
  imports?: ValueWithIgnore;
  exports?: ValueWithIgnore;
  functions?: ValueWithIgnore;
  importAttributes?: ValueWithIgnore;
  dynamicImports?: ValueWithIgnore;
  enums?: ValueWithIgnore;
  generics?: ValueWithIgnore;
  tuples?: ValueWithIgnore;
}];
type Value = 'always-multiline' | 'always' | 'never' | 'only-multiline';
type ValueWithIgnore = 'always-multiline' | 'always' | 'never' | 'only-multiline' | 'ignore';
type CommaDangleRuleOptions = CommaDangleSchema0;
//#endregion
//#region rules/comma-spacing/types.d.ts

interface CommaSpacingSchema0 {
  before?: boolean;
  after?: boolean;
}
type CommaSpacingRuleOptions = [CommaSpacingSchema0?];
//#endregion
//#region rules/comma-style/types.d.ts

type CommaStyleSchema0 = 'first' | 'last';
interface CommaStyleSchema1 {
  exceptions?: {
    [k: string]: boolean;
  };
}
type CommaStyleRuleOptions = [CommaStyleSchema0?, CommaStyleSchema1?];
//#endregion
//#region rules/computed-property-spacing/types.d.ts

type ComputedPropertySpacingSchema0 = 'always' | 'never';
interface ComputedPropertySpacingSchema1 {
  enforceForClassMembers?: boolean;
}
type ComputedPropertySpacingRuleOptions = [ComputedPropertySpacingSchema0?, ComputedPropertySpacingSchema1?];
//#endregion
//#region rules/curly-newline/types.d.ts

type CurlyNewlineSchema0 = ('always' | 'never') | {
  IfStatementConsequent?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  IfStatementAlternative?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  DoWhileStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  ForInStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  ForOfStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  ForStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  WhileStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  SwitchStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  SwitchCase?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  TryStatementBlock?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  TryStatementHandler?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  TryStatementFinalizer?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  BlockStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  ArrowFunctionExpression?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  FunctionDeclaration?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  FunctionExpression?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  Property?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  ClassBody?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  StaticBlock?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  WithStatement?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  TSModuleBlock?: ('always' | 'never') | {
    multiline?: boolean;
    minElements?: number;
    consistent?: boolean;
  };
  multiline?: boolean;
  minElements?: number;
  consistent?: boolean;
};
type CurlyNewlineRuleOptions = [CurlyNewlineSchema0?];
//#endregion
//#region rules/dot-location/types.d.ts

type DotLocationSchema0 = 'object' | 'property';
type DotLocationRuleOptions = [DotLocationSchema0?];
//#endregion
//#region rules/eol-last/types.d.ts

type EolLastSchema0 = 'always' | 'never' | 'unix' | 'windows';
type EolLastRuleOptions = [EolLastSchema0?];
//#endregion
//#region rules/function-call-argument-newline/types.d.ts

type FunctionCallArgumentNewlineSchema0 = 'always' | 'never' | 'consistent';
type FunctionCallArgumentNewlineRuleOptions = [FunctionCallArgumentNewlineSchema0?];
//#endregion
//#region rules/function-call-spacing/types.d.ts

type FunctionCallSpacingSchema0 = [] | ['never'] | [] | ['always'] | ['always', {
  allowNewlines?: boolean;
  optionalChain?: {
    before?: boolean;
    after?: boolean;
  };
}];
type FunctionCallSpacingRuleOptions = FunctionCallSpacingSchema0;
//#endregion
//#region rules/function-paren-newline/types.d.ts

type FunctionParenNewlineSchema0 = ('always' | 'never' | 'consistent' | 'multiline' | 'multiline-arguments') | {
  minItems?: number;
};
type FunctionParenNewlineRuleOptions = [FunctionParenNewlineSchema0?];
//#endregion
//#region rules/generator-star-spacing/types.d.ts

type GeneratorStarSpacingSchema0 = ('before' | 'after' | 'both' | 'neither') | {
  before?: boolean;
  after?: boolean;
  named?: ('before' | 'after' | 'both' | 'neither') | {
    before?: boolean;
    after?: boolean;
  };
  anonymous?: ('before' | 'after' | 'both' | 'neither') | {
    before?: boolean;
    after?: boolean;
  };
  method?: ('before' | 'after' | 'both' | 'neither') | {
    before?: boolean;
    after?: boolean;
  };
  shorthand?: ('before' | 'after' | 'both' | 'neither') | {
    before?: boolean;
    after?: boolean;
  };
};
type GeneratorStarSpacingRuleOptions = [GeneratorStarSpacingSchema0?];
//#endregion
//#region rules/implicit-arrow-linebreak/types.d.ts

type ImplicitArrowLinebreakSchema0 = 'beside' | 'below';
type ImplicitArrowLinebreakRuleOptions = [ImplicitArrowLinebreakSchema0?];
//#endregion
//#region rules/indent-binary-ops/types.d.ts

type IndentBinaryOpsSchema0 = number | 'tab';
type IndentBinaryOpsRuleOptions = [IndentBinaryOpsSchema0?];
//#endregion
//#region rules/indent/types.d.ts

type IndentSchema0 = 'tab' | number;
interface IndentSchema1 {
  SwitchCase?: number;
  VariableDeclarator?: (number | ('first' | 'off')) | {
    var?: number | ('first' | 'off');
    let?: number | ('first' | 'off');
    const?: number | ('first' | 'off');
    using?: number | ('first' | 'off');
  };
  assignmentOperator?: number | 'off';
  outerIIFEBody?: number | 'off';
  MemberExpression?: number | 'off';
  FunctionDeclaration?: {
    parameters?: number | ('first' | 'off');
    body?: number;
    returnType?: number;
  };
  FunctionExpression?: {
    parameters?: number | ('first' | 'off');
    body?: number;
    returnType?: number;
  };
  StaticBlock?: {
    body?: number;
  };
  CallExpression?: {
    arguments?: number | ('first' | 'off');
  };
  ArrayExpression?: number | ('first' | 'off');
  ObjectExpression?: number | ('first' | 'off');
  ImportDeclaration?: number | ('first' | 'off');
  flatTernaryExpressions?: boolean;
  offsetTernaryExpressions?: boolean;
  offsetTernaryExpressionsOffsetCallExpressions?: boolean;
  ignoredNodes?: string[];
  ignoreComments?: boolean;
  tabLength?: number;
}
type IndentRuleOptions = [IndentSchema0?, IndentSchema1?];
//#endregion
//#region rules/jsx-child-element-spacing/types.d.ts

type JsxChildElementSpacingRuleOptions = [];
//#endregion
//#region rules/jsx-closing-bracket-location/types.d.ts

type JsxClosingBracketLocationSchema0 = ('after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned') | {
  location?: 'after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned';
} | {
  nonEmpty?: ('after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned') | false;
  selfClosing?: ('after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned') | false;
};
type JsxClosingBracketLocationRuleOptions = [JsxClosingBracketLocationSchema0?];
//#endregion
//#region rules/jsx-closing-tag-location/types.d.ts

type JsxClosingTagLocationSchema0 = 'tag-aligned' | 'line-aligned';
type JsxClosingTagLocationRuleOptions = [JsxClosingTagLocationSchema0?];
//#endregion
//#region rules/jsx-curly-brace-presence/types.d.ts

type JsxCurlyBracePresenceSchema0 = {
  props?: 'always' | 'never' | 'ignore';
  children?: 'always' | 'never' | 'ignore';
  propElementValues?: 'always' | 'never' | 'ignore';
} | ('always' | 'never' | 'ignore');
type JsxCurlyBracePresenceRuleOptions = [JsxCurlyBracePresenceSchema0?];
//#endregion
//#region rules/jsx-curly-newline/types.d.ts

type JsxCurlyNewlineSchema0 = ('consistent' | 'never') | {
  singleline?: 'consistent' | 'require' | 'forbid';
  multiline?: 'consistent' | 'require' | 'forbid';
};
type JsxCurlyNewlineRuleOptions = [JsxCurlyNewlineSchema0?];
//#endregion
//#region rules/jsx-curly-spacing/types.d.ts

type JsxCurlySpacingSchema0 = [] | [{
  when?: 'always' | 'never';
  allowMultiline?: boolean;
  spacing?: {
    objectLiterals?: 'always' | 'never';
  };
  attributes?: {
    when?: 'always' | 'never';
    allowMultiline?: boolean;
    spacing?: {
      objectLiterals?: 'always' | 'never';
    };
  } | boolean;
  children?: {
    when?: 'always' | 'never';
    allowMultiline?: boolean;
    spacing?: {
      objectLiterals?: 'always' | 'never';
    };
  } | boolean;
} | ('always' | 'never')] | [({
  when?: 'always' | 'never';
  allowMultiline?: boolean;
  spacing?: {
    objectLiterals?: 'always' | 'never';
  };
  attributes?: {
    when?: 'always' | 'never';
    allowMultiline?: boolean;
    spacing?: {
      objectLiterals?: 'always' | 'never';
    };
  } | boolean;
  children?: {
    when?: 'always' | 'never';
    allowMultiline?: boolean;
    spacing?: {
      objectLiterals?: 'always' | 'never';
    };
  } | boolean;
} | ('always' | 'never')), {
  allowMultiline?: boolean;
  spacing?: {
    objectLiterals?: 'always' | 'never';
  };
}];
type JsxCurlySpacingRuleOptions = JsxCurlySpacingSchema0;
//#endregion
//#region rules/jsx-equals-spacing/types.d.ts

type JsxEqualsSpacingSchema0 = 'always' | 'never';
type JsxEqualsSpacingRuleOptions = [JsxEqualsSpacingSchema0?];
//#endregion
//#region rules/jsx-first-prop-new-line/types.d.ts

type JsxFirstPropNewLineSchema0 = 'always' | 'never' | 'multiline' | 'multiline-multiprop' | 'multiprop';
type JsxFirstPropNewLineRuleOptions = [JsxFirstPropNewLineSchema0?];
//#endregion
//#region rules/jsx-function-call-newline/types.d.ts

type JsxFunctionCallNewlineSchema0 = 'always' | 'multiline';
type JsxFunctionCallNewlineRuleOptions = [JsxFunctionCallNewlineSchema0?];
//#endregion
//#region rules/jsx-indent-props/types.d.ts

type JsxIndentPropsSchema0 = ('tab' | 'first') | number | {
  indentMode?: ('tab' | 'first') | number;
  ignoreTernaryOperator?: boolean;
};
type JsxIndentPropsRuleOptions = [JsxIndentPropsSchema0?];
//#endregion
//#region rules/jsx-indent/types.d.ts

type JsxIndentSchema0 = 'tab' | number;
interface JsxIndentSchema1 {
  checkAttributes?: boolean;
  indentLogicalExpressions?: boolean;
}
type JsxIndentRuleOptions = [JsxIndentSchema0?, JsxIndentSchema1?];
//#endregion
//#region rules/jsx-max-props-per-line/types.d.ts

type JsxMaxPropsPerLineSchema0 = {
  maximum?: {
    single?: number;
    multi?: number;
  };
} | {
  maximum?: number;
  when?: 'always' | 'multiline';
};
type JsxMaxPropsPerLineRuleOptions = [JsxMaxPropsPerLineSchema0?];
//#endregion
//#region rules/jsx-newline/types.d.ts

interface JsxNewlineSchema0 {
  prevent?: boolean;
  allowMultilines?: boolean;
}
type JsxNewlineRuleOptions = [JsxNewlineSchema0?];
//#endregion
//#region rules/jsx-one-expression-per-line/types.d.ts

interface JsxOneExpressionPerLineSchema0 {
  allow?: 'none' | 'literal' | 'single-child' | 'single-line' | 'non-jsx';
}
type JsxOneExpressionPerLineRuleOptions = [JsxOneExpressionPerLineSchema0?];
//#endregion
//#region rules/jsx-pascal-case/types.d.ts

interface JsxPascalCaseSchema0 {
  allowAllCaps?: boolean;
  allowLeadingUnderscore?: boolean;
  allowNamespace?: boolean;
  ignore?: string[];
}
type JsxPascalCaseRuleOptions = [JsxPascalCaseSchema0?];
//#endregion
//#region rules/jsx-props-no-multi-spaces/types.d.ts

type JsxPropsNoMultiSpacesRuleOptions = [];
//#endregion
//#region rules/jsx-quotes/types.d.ts

type JsxQuotesSchema0 = 'prefer-single' | 'prefer-double';
type JsxQuotesRuleOptions = [JsxQuotesSchema0?];
//#endregion
//#region rules/jsx-self-closing-comp/types.d.ts

interface JsxSelfClosingCompSchema0 {
  component?: boolean;
  html?: boolean;
}
type JsxSelfClosingCompRuleOptions = [JsxSelfClosingCompSchema0?];
//#endregion
//#region rules/jsx-sort-props/types.d.ts

interface JsxSortPropsSchema0 {
  callbacksLast?: boolean;
  shorthandFirst?: boolean;
  shorthandLast?: boolean;
  multiline?: 'ignore' | 'first' | 'last';
  ignoreCase?: boolean;
  noSortAlphabetically?: boolean;
  reservedFirst?: string[] | boolean;
  reservedLast?: string[];
  locale?: string;
}
type JsxSortPropsRuleOptions = [JsxSortPropsSchema0?];
//#endregion
//#region rules/jsx-tag-spacing/types.d.ts

interface JsxTagSpacingSchema0 {
  closingSlash?: 'always' | 'never' | 'allow';
  beforeSelfClosing?: 'always' | 'proportional-always' | 'never' | 'allow';
  afterOpening?: 'always' | 'allow-multiline' | 'never' | 'allow';
  beforeClosing?: 'always' | 'proportional-always' | 'never' | 'allow';
}
type JsxTagSpacingRuleOptions = [JsxTagSpacingSchema0?];
//#endregion
//#region rules/jsx-wrap-multilines/types.d.ts

interface JsxWrapMultilinesSchema0 {
  declaration?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  assignment?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  return?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  arrow?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  condition?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  logical?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  prop?: true | false | 'ignore' | 'parens' | 'parens-new-line';
  propertyValue?: true | false | 'ignore' | 'parens' | 'parens-new-line';
}
type JsxWrapMultilinesRuleOptions = [JsxWrapMultilinesSchema0?];
//#endregion
//#region rules/key-spacing/types.d.ts

type KeySpacingSchema0 = {
  align?: ('colon' | 'value') | {
    mode?: 'strict' | 'minimum';
    on?: 'colon' | 'value';
    beforeColon?: boolean;
    afterColon?: boolean;
  };
  mode?: 'strict' | 'minimum';
  beforeColon?: boolean;
  afterColon?: boolean;
  ignoredNodes?: ('ObjectExpression' | 'ObjectPattern' | 'ImportDeclaration' | 'ExportNamedDeclaration' | 'ExportAllDeclaration' | 'TSTypeLiteral' | 'TSInterfaceBody' | 'ClassBody')[];
} | {
  singleLine?: {
    mode?: 'strict' | 'minimum';
    beforeColon?: boolean;
    afterColon?: boolean;
  };
  multiLine?: {
    align?: ('colon' | 'value') | {
      mode?: 'strict' | 'minimum';
      on?: 'colon' | 'value';
      beforeColon?: boolean;
      afterColon?: boolean;
    };
    mode?: 'strict' | 'minimum';
    beforeColon?: boolean;
    afterColon?: boolean;
  };
} | {
  singleLine?: {
    mode?: 'strict' | 'minimum';
    beforeColon?: boolean;
    afterColon?: boolean;
  };
  multiLine?: {
    mode?: 'strict' | 'minimum';
    beforeColon?: boolean;
    afterColon?: boolean;
  };
  align?: {
    mode?: 'strict' | 'minimum';
    on?: 'colon' | 'value';
    beforeColon?: boolean;
    afterColon?: boolean;
  };
};
type KeySpacingRuleOptions = [KeySpacingSchema0?];
//#endregion
//#region rules/keyword-spacing/types.d.ts

interface KeywordSpacingSchema0 {
  before?: boolean;
  after?: boolean;
  overrides?: {
    abstract?: {
      before?: boolean;
      after?: boolean;
    };
    boolean?: {
      before?: boolean;
      after?: boolean;
    };
    break?: {
      before?: boolean;
      after?: boolean;
    };
    byte?: {
      before?: boolean;
      after?: boolean;
    };
    case?: {
      before?: boolean;
      after?: boolean;
    };
    catch?: {
      before?: boolean;
      after?: boolean;
    };
    char?: {
      before?: boolean;
      after?: boolean;
    };
    class?: {
      before?: boolean;
      after?: boolean;
    };
    const?: {
      before?: boolean;
      after?: boolean;
    };
    continue?: {
      before?: boolean;
      after?: boolean;
    };
    debugger?: {
      before?: boolean;
      after?: boolean;
    };
    default?: {
      before?: boolean;
      after?: boolean;
    };
    delete?: {
      before?: boolean;
      after?: boolean;
    };
    do?: {
      before?: boolean;
      after?: boolean;
    };
    double?: {
      before?: boolean;
      after?: boolean;
    };
    else?: {
      before?: boolean;
      after?: boolean;
    };
    enum?: {
      before?: boolean;
      after?: boolean;
    };
    export?: {
      before?: boolean;
      after?: boolean;
    };
    extends?: {
      before?: boolean;
      after?: boolean;
    };
    false?: {
      before?: boolean;
      after?: boolean;
    };
    final?: {
      before?: boolean;
      after?: boolean;
    };
    finally?: {
      before?: boolean;
      after?: boolean;
    };
    float?: {
      before?: boolean;
      after?: boolean;
    };
    for?: {
      before?: boolean;
      after?: boolean;
    };
    function?: {
      before?: boolean;
      after?: boolean;
    };
    goto?: {
      before?: boolean;
      after?: boolean;
    };
    if?: {
      before?: boolean;
      after?: boolean;
    };
    implements?: {
      before?: boolean;
      after?: boolean;
    };
    import?: {
      before?: boolean;
      after?: boolean;
    };
    in?: {
      before?: boolean;
      after?: boolean;
    };
    instanceof?: {
      before?: boolean;
      after?: boolean;
    };
    int?: {
      before?: boolean;
      after?: boolean;
    };
    interface?: {
      before?: boolean;
      after?: boolean;
    };
    long?: {
      before?: boolean;
      after?: boolean;
    };
    native?: {
      before?: boolean;
      after?: boolean;
    };
    new?: {
      before?: boolean;
      after?: boolean;
    };
    null?: {
      before?: boolean;
      after?: boolean;
    };
    package?: {
      before?: boolean;
      after?: boolean;
    };
    private?: {
      before?: boolean;
      after?: boolean;
    };
    protected?: {
      before?: boolean;
      after?: boolean;
    };
    public?: {
      before?: boolean;
      after?: boolean;
    };
    return?: {
      before?: boolean;
      after?: boolean;
    };
    short?: {
      before?: boolean;
      after?: boolean;
    };
    static?: {
      before?: boolean;
      after?: boolean;
    };
    super?: {
      before?: boolean;
      after?: boolean;
    };
    switch?: {
      before?: boolean;
      after?: boolean;
    };
    synchronized?: {
      before?: boolean;
      after?: boolean;
    };
    this?: {
      before?: boolean;
      after?: boolean;
    };
    throw?: {
      before?: boolean;
      after?: boolean;
    };
    throws?: {
      before?: boolean;
      after?: boolean;
    };
    transient?: {
      before?: boolean;
      after?: boolean;
    };
    true?: {
      before?: boolean;
      after?: boolean;
    };
    try?: {
      before?: boolean;
      after?: boolean;
    };
    typeof?: {
      before?: boolean;
      after?: boolean;
    };
    var?: {
      before?: boolean;
      after?: boolean;
    };
    void?: {
      before?: boolean;
      after?: boolean;
    };
    volatile?: {
      before?: boolean;
      after?: boolean;
    };
    while?: {
      before?: boolean;
      after?: boolean;
    };
    with?: {
      before?: boolean;
      after?: boolean;
    };
    arguments?: {
      before?: boolean;
      after?: boolean;
    };
    as?: {
      before?: boolean;
      after?: boolean;
    };
    async?: {
      before?: boolean;
      after?: boolean;
    };
    await?: {
      before?: boolean;
      after?: boolean;
    };
    eval?: {
      before?: boolean;
      after?: boolean;
    };
    from?: {
      before?: boolean;
      after?: boolean;
    };
    get?: {
      before?: boolean;
      after?: boolean;
    };
    let?: {
      before?: boolean;
      after?: boolean;
    };
    of?: {
      before?: boolean;
      after?: boolean;
    };
    set?: {
      before?: boolean;
      after?: boolean;
    };
    type?: {
      before?: boolean;
      after?: boolean;
    };
    using?: {
      before?: boolean;
      after?: boolean;
    };
    yield?: {
      before?: boolean;
      after?: boolean;
    };
    accessor?: {
      before?: boolean;
      after?: boolean;
    };
    satisfies?: {
      before?: boolean;
      after?: boolean;
    };
  };
}
type KeywordSpacingRuleOptions = [KeywordSpacingSchema0?];
//#endregion
//#region rules/line-comment-position/types.d.ts

type LineCommentPositionSchema0 = ('above' | 'beside') | {
  position?: 'above' | 'beside';
  ignorePattern?: string;
  applyDefaultPatterns?: boolean;
  applyDefaultIgnorePatterns?: boolean;
};
type LineCommentPositionRuleOptions = [LineCommentPositionSchema0?];
//#endregion
//#region rules/linebreak-style/types.d.ts

type LinebreakStyleSchema0 = 'unix' | 'windows';
type LinebreakStyleRuleOptions = [LinebreakStyleSchema0?];
//#endregion
//#region rules/lines-around-comment/types.d.ts

interface LinesAroundCommentSchema0 {
  beforeBlockComment?: boolean;
  afterBlockComment?: boolean;
  beforeLineComment?: boolean;
  afterLineComment?: boolean;
  allowBlockStart?: boolean;
  allowBlockEnd?: boolean;
  allowClassStart?: boolean;
  allowClassEnd?: boolean;
  allowObjectStart?: boolean;
  allowObjectEnd?: boolean;
  allowArrayStart?: boolean;
  allowArrayEnd?: boolean;
  allowInterfaceStart?: boolean;
  allowInterfaceEnd?: boolean;
  allowTypeStart?: boolean;
  allowTypeEnd?: boolean;
  allowEnumStart?: boolean;
  allowEnumEnd?: boolean;
  allowModuleStart?: boolean;
  allowModuleEnd?: boolean;
  ignorePattern?: string;
  applyDefaultIgnorePatterns?: boolean;
  afterHashbangComment?: boolean;
}
type LinesAroundCommentRuleOptions = [LinesAroundCommentSchema0?];
//#endregion
//#region rules/lines-between-class-members/types.d.ts

type LinesBetweenClassMembersSchema0 = {
  /**
   * @minItems 1
   */
  enforce: [{
    blankLine: 'always' | 'never';
    prev: 'method' | 'field' | '*';
    next: 'method' | 'field' | '*';
  }, ...{
    blankLine: 'always' | 'never';
    prev: 'method' | 'field' | '*';
    next: 'method' | 'field' | '*';
  }[]];
} | ('always' | 'never');
interface LinesBetweenClassMembersSchema1 {
  exceptAfterSingleLine?: boolean;
  exceptAfterOverload?: boolean;
}
type LinesBetweenClassMembersRuleOptions = [LinesBetweenClassMembersSchema0?, LinesBetweenClassMembersSchema1?];
//#endregion
//#region rules/max-len/types.d.ts

type MaxLenSchema0 = {
  code?: number;
  comments?: number;
  tabWidth?: number;
  ignorePattern?: string;
  ignoreComments?: boolean;
  ignoreStrings?: boolean;
  ignoreUrls?: boolean;
  ignoreTemplateLiterals?: boolean;
  ignoreRegExpLiterals?: boolean;
  ignoreTrailingComments?: boolean;
} | number;
type MaxLenSchema1 = {
  code?: number;
  comments?: number;
  tabWidth?: number;
  ignorePattern?: string;
  ignoreComments?: boolean;
  ignoreStrings?: boolean;
  ignoreUrls?: boolean;
  ignoreTemplateLiterals?: boolean;
  ignoreRegExpLiterals?: boolean;
  ignoreTrailingComments?: boolean;
} | number;
interface MaxLenSchema2 {
  code?: number;
  comments?: number;
  tabWidth?: number;
  ignorePattern?: string;
  ignoreComments?: boolean;
  ignoreStrings?: boolean;
  ignoreUrls?: boolean;
  ignoreTemplateLiterals?: boolean;
  ignoreRegExpLiterals?: boolean;
  ignoreTrailingComments?: boolean;
}
type MaxLenRuleOptions = [MaxLenSchema0?, MaxLenSchema1?, MaxLenSchema2?];
//#endregion
//#region rules/max-statements-per-line/types.d.ts

interface MaxStatementsPerLineSchema0 {
  max?: number;
  ignoredNodes?: ('BreakStatement' | 'ClassDeclaration' | 'ContinueStatement' | 'DebuggerStatement' | 'DoWhileStatement' | 'ExpressionStatement' | 'ForInStatement' | 'ForOfStatement' | 'ForStatement' | 'FunctionDeclaration' | 'IfStatement' | 'ImportDeclaration' | 'LabeledStatement' | 'ReturnStatement' | 'SwitchStatement' | 'ThrowStatement' | 'TryStatement' | 'VariableDeclaration' | 'WhileStatement' | 'WithStatement' | 'ExportNamedDeclaration' | 'ExportDefaultDeclaration' | 'ExportAllDeclaration')[];
}
type MaxStatementsPerLineRuleOptions = [MaxStatementsPerLineSchema0?];
//#endregion
//#region rules/member-delimiter-style/types.d.ts

type MultiLineOption = 'none' | 'semi' | 'comma';
type SingleLineOption = 'semi' | 'comma';
interface MemberDelimiterStyleSchema0 {
  multiline?: {
    delimiter?: MultiLineOption;
    requireLast?: boolean;
  };
  singleline?: {
    delimiter?: SingleLineOption;
    requireLast?: boolean;
  };
  overrides?: {
    interface?: DelimiterConfig;
    typeLiteral?: DelimiterConfig;
  };
  multilineDetection?: 'brackets' | 'last-member';
}
interface DelimiterConfig {
  multiline?: {
    delimiter?: MultiLineOption;
    requireLast?: boolean;
  };
  singleline?: {
    delimiter?: SingleLineOption;
    requireLast?: boolean;
  };
}
type MemberDelimiterStyleRuleOptions = [MemberDelimiterStyleSchema0?];
//#endregion
//#region rules/multiline-comment-style/types.d.ts

type MultilineCommentStyleSchema0 = [] | ['starred-block' | 'bare-block'] | [] | ['separate-lines'] | ['separate-lines', {
  checkJSDoc?: boolean;
  checkExclamation?: boolean;
}];
type MultilineCommentStyleRuleOptions = MultilineCommentStyleSchema0;
//#endregion
//#region rules/multiline-ternary/types.d.ts

type MultilineTernarySchema0 = 'always' | 'always-multiline' | 'never';
interface MultilineTernarySchema1 {
  ignoreJSX?: boolean;
}
type MultilineTernaryRuleOptions = [MultilineTernarySchema0?, MultilineTernarySchema1?];
//#endregion
//#region rules/new-parens/types.d.ts

type NewParensSchema0 = 'always' | 'never';
type NewParensRuleOptions = [NewParensSchema0?];
//#endregion
//#region rules/newline-per-chained-call/types.d.ts

interface NewlinePerChainedCallSchema0 {
  ignoreChainWithDepth?: number;
}
type NewlinePerChainedCallRuleOptions = [NewlinePerChainedCallSchema0?];
//#endregion
//#region rules/no-confusing-arrow/types.d.ts

interface NoConfusingArrowSchema0 {
  allowParens?: boolean;
  onlyOneSimpleParam?: boolean;
}
type NoConfusingArrowRuleOptions = [NoConfusingArrowSchema0?];
//#endregion
//#region rules/no-extra-parens/types.d.ts

type NoExtraParensSchema0 = [] | ['functions'] | [] | ['all'] | ['all', {
  conditionalAssign?: boolean;
  ternaryOperandBinaryExpressions?: boolean;
  nestedBinaryExpressions?: boolean;
  returnAssign?: boolean;
  ignoreJSX?: 'none' | 'all' | 'single-line' | 'multi-line';
  enforceForArrowConditionals?: boolean;
  enforceForSequenceExpressions?: boolean;
  enforceForNewInMemberExpressions?: boolean;
  enforceForFunctionPrototypeMethods?: boolean;
  allowParensAfterCommentPattern?: string;
  nestedConditionalExpressions?: boolean;
  allowNodesInSpreadElement?: {
    ConditionalExpression?: boolean;
    LogicalExpression?: boolean;
    AwaitExpression?: boolean;
  };
  ignoredNodes?: string[];
}];
type NoExtraParensRuleOptions = NoExtraParensSchema0;
//#endregion
//#region rules/no-extra-semi/types.d.ts

type NoExtraSemiRuleOptions = [];
//#endregion
//#region rules/no-floating-decimal/types.d.ts

type NoFloatingDecimalRuleOptions = [];
//#endregion
//#region rules/no-mixed-operators/types.d.ts

interface NoMixedOperatorsSchema0 {
  groups?: [('+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||' | 'in' | 'instanceof' | '?:' | '??'), ('+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||' | 'in' | 'instanceof' | '?:' | '??'), ...('+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||' | 'in' | 'instanceof' | '?:' | '??')[]][];
  allowSamePrecedence?: boolean;
}
type NoMixedOperatorsRuleOptions = [NoMixedOperatorsSchema0?];
//#endregion
//#region rules/no-mixed-spaces-and-tabs/types.d.ts

type NoMixedSpacesAndTabsSchema0 = 'smart-tabs' | boolean;
type NoMixedSpacesAndTabsRuleOptions = [NoMixedSpacesAndTabsSchema0?];
//#endregion
//#region rules/no-multi-spaces/types.d.ts

interface NoMultiSpacesSchema0 {
  exceptions?: {
    [k: string]: boolean;
  };
  ignoreEOLComments?: boolean;
  includeTabs?: boolean;
}
type NoMultiSpacesRuleOptions = [NoMultiSpacesSchema0?];
//#endregion
//#region rules/no-multiple-empty-lines/types.d.ts

interface NoMultipleEmptyLinesSchema0 {
  max: number;
  maxEOF?: number;
  maxBOF?: number;
}
type NoMultipleEmptyLinesRuleOptions = [NoMultipleEmptyLinesSchema0?];
//#endregion
//#region rules/no-tabs/types.d.ts

interface NoTabsSchema0 {
  allowIndentationTabs?: boolean;
}
type NoTabsRuleOptions = [NoTabsSchema0?];
//#endregion
//#region rules/no-trailing-spaces/types.d.ts

interface NoTrailingSpacesSchema0 {
  skipBlankLines?: boolean;
  ignoreComments?: boolean;
}
type NoTrailingSpacesRuleOptions = [NoTrailingSpacesSchema0?];
//#endregion
//#region rules/no-whitespace-before-property/types.d.ts

type NoWhitespaceBeforePropertyRuleOptions = [];
//#endregion
//#region rules/nonblock-statement-body-position/types.d.ts

type NonblockStatementBodyPositionSchema0 = 'beside' | 'below' | 'any';
interface NonblockStatementBodyPositionSchema1 {
  overrides?: {
    if?: 'beside' | 'below' | 'any';
    else?: 'beside' | 'below' | 'any';
    while?: 'beside' | 'below' | 'any';
    do?: 'beside' | 'below' | 'any';
    for?: 'beside' | 'below' | 'any';
  };
}
type NonblockStatementBodyPositionRuleOptions = [NonblockStatementBodyPositionSchema0?, NonblockStatementBodyPositionSchema1?];
//#endregion
//#region rules/object-curly-newline/types.d.ts

type ObjectCurlyNewlineSchema0 = (('always' | 'never') | {
  multiline?: boolean;
  minProperties?: number;
  consistent?: boolean;
}) | {
  ObjectExpression?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
  ObjectPattern?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
  ImportDeclaration?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
  ExportDeclaration?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
  TSTypeLiteral?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
  TSInterfaceBody?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
  TSEnumBody?: ('always' | 'never') | {
    multiline?: boolean;
    minProperties?: number;
    consistent?: boolean;
  };
};
type ObjectCurlyNewlineRuleOptions = [ObjectCurlyNewlineSchema0?];
//#endregion
//#region rules/object-curly-spacing/types.d.ts

type ObjectCurlySpacingSchema0 = 'always' | 'never';
interface ObjectCurlySpacingSchema1 {
  arraysInObjects?: boolean;
  objectsInObjects?: boolean;
  overrides?: {
    ObjectPattern?: 'always' | 'never';
    ObjectExpression?: 'always' | 'never';
    ImportDeclaration?: 'always' | 'never';
    ImportAttributes?: 'always' | 'never';
    ExportNamedDeclaration?: 'always' | 'never';
    ExportAllDeclaration?: 'always' | 'never';
    TSMappedType?: 'always' | 'never';
    TSTypeLiteral?: 'always' | 'never';
    TSInterfaceBody?: 'always' | 'never';
    TSEnumBody?: 'always' | 'never';
  };
}
type ObjectCurlySpacingRuleOptions = [ObjectCurlySpacingSchema0?, ObjectCurlySpacingSchema1?];
//#endregion
//#region rules/object-property-newline/types.d.ts

interface ObjectPropertyNewlineSchema0 {
  allowAllPropertiesOnSameLine?: boolean;
}
type ObjectPropertyNewlineRuleOptions = [ObjectPropertyNewlineSchema0?];
//#endregion
//#region rules/one-var-declaration-per-line/types.d.ts

type OneVarDeclarationPerLineSchema0 = 'always' | 'initializations';
type OneVarDeclarationPerLineRuleOptions = [OneVarDeclarationPerLineSchema0?];
//#endregion
//#region rules/operator-linebreak/types.d.ts

type OperatorLinebreakSchema0 = ('after' | 'before' | 'none') | null;
interface OperatorLinebreakSchema1 {
  overrides?: {
    [k: string]: 'after' | 'before' | 'none' | 'ignore';
  };
}
type OperatorLinebreakRuleOptions = [OperatorLinebreakSchema0?, OperatorLinebreakSchema1?];
//#endregion
//#region rules/padded-blocks/types.d.ts

type PaddedBlocksSchema0 = ('always' | 'never' | 'start' | 'end') | {
  blocks?: 'always' | 'never' | 'start' | 'end';
  switches?: 'always' | 'never' | 'start' | 'end';
  classes?: 'always' | 'never' | 'start' | 'end';
};
interface PaddedBlocksSchema1 {
  allowSingleLineBlocks?: boolean;
}
type PaddedBlocksRuleOptions = [PaddedBlocksSchema0?, PaddedBlocksSchema1?];
//#endregion
//#region rules/padding-line-between-statements/types.d.ts

type PaddingType = 'any' | 'never' | 'always';
type StatementOption = StatementType | [StatementType, ...StatementType[]];
type StatementType = '*' | 'exports' | 'require' | 'directive' | 'iife' | 'block' | 'empty' | 'function' | 'ts-method' | 'break' | 'case' | 'class' | 'continue' | 'debugger' | 'default' | 'do' | 'for' | 'if' | 'import' | 'switch' | 'throw' | 'try' | 'while' | 'with' | 'cjs-export' | 'cjs-import' | 'enum' | 'interface' | 'function-overload' | 'block-like' | 'singleline-block-like' | 'multiline-block-like' | 'expression' | 'singleline-expression' | 'multiline-expression' | 'return' | 'singleline-return' | 'multiline-return' | 'export' | 'singleline-export' | 'multiline-export' | 'var' | 'singleline-var' | 'multiline-var' | 'let' | 'singleline-let' | 'multiline-let' | 'const' | 'singleline-const' | 'multiline-const' | 'using' | 'singleline-using' | 'multiline-using' | 'type' | 'singleline-type' | 'multiline-type';
type PaddingLineBetweenStatementsSchema0 = {
  blankLine: PaddingType;
  prev: StatementOption;
  next: StatementOption;
}[];
type PaddingLineBetweenStatementsRuleOptions = PaddingLineBetweenStatementsSchema0;
//#endregion
//#region rules/quote-props/types.d.ts

type QuotePropsSchema0 = [] | ['always' | 'as-needed' | 'consistent' | 'consistent-as-needed'] | [] | ['always' | 'as-needed' | 'consistent' | 'consistent-as-needed'] | [('always' | 'as-needed' | 'consistent' | 'consistent-as-needed'), {
  keywords?: boolean;
  unnecessary?: boolean;
  numbers?: boolean;
}];
type QuotePropsRuleOptions = QuotePropsSchema0;
//#endregion
//#region rules/quotes/types.d.ts

type QuotesSchema0 = 'single' | 'double' | 'backtick';
type QuotesSchema1 = 'avoid-escape' | {
  avoidEscape?: boolean;
  allowTemplateLiterals?: boolean | ('never' | 'avoidEscape' | 'always');
  ignoreStringLiterals?: boolean;
};
type QuotesRuleOptions = [QuotesSchema0?, QuotesSchema1?];
//#endregion
//#region rules/rest-spread-spacing/types.d.ts

type RestSpreadSpacingSchema0 = 'always' | 'never';
type RestSpreadSpacingRuleOptions = [RestSpreadSpacingSchema0?];
//#endregion
//#region rules/semi-spacing/types.d.ts

interface SemiSpacingSchema0 {
  before?: boolean;
  after?: boolean;
}
type SemiSpacingRuleOptions = [SemiSpacingSchema0?];
//#endregion
//#region rules/semi-style/types.d.ts

type SemiStyleSchema0 = 'last' | 'first';
type SemiStyleRuleOptions = [SemiStyleSchema0?];
//#endregion
//#region rules/semi/types.d.ts

type SemiSchema0 = [] | ['never'] | ['never', {
  beforeStatementContinuationChars?: 'always' | 'any' | 'never';
}] | [] | ['always'] | ['always', {
  omitLastInOneLineBlock?: boolean;
  omitLastInOneLineClassBody?: boolean;
}];
type SemiRuleOptions = SemiSchema0;
//#endregion
//#region rules/space-before-blocks/types.d.ts

type SpaceBeforeBlocksSchema0 = ('always' | 'never') | {
  keywords?: 'always' | 'never' | 'off';
  functions?: 'always' | 'never' | 'off';
  classes?: 'always' | 'never' | 'off';
  modules?: 'always' | 'never' | 'off';
};
type SpaceBeforeBlocksRuleOptions = [SpaceBeforeBlocksSchema0?];
//#endregion
//#region rules/space-before-function-paren/types.d.ts

type SpaceBeforeFunctionParenSchema0 = ('always' | 'never') | {
  anonymous?: 'always' | 'never' | 'ignore';
  named?: 'always' | 'never' | 'ignore';
  asyncArrow?: 'always' | 'never' | 'ignore';
  catch?: 'always' | 'never' | 'ignore';
};
type SpaceBeforeFunctionParenRuleOptions = [SpaceBeforeFunctionParenSchema0?];
//#endregion
//#region rules/space-in-parens/types.d.ts

type SpaceInParensSchema0 = 'always' | 'never';
interface SpaceInParensSchema1 {
  exceptions?: ('{}' | '[]' | '()' | 'empty')[];
}
type SpaceInParensRuleOptions = [SpaceInParensSchema0?, SpaceInParensSchema1?];
//#endregion
//#region rules/space-infix-ops/types.d.ts

interface SpaceInfixOpsSchema0 {
  int32Hint?: boolean;
  ignoreTypes?: boolean;
}
type SpaceInfixOpsRuleOptions = [SpaceInfixOpsSchema0?];
//#endregion
//#region rules/space-unary-ops/types.d.ts

interface SpaceUnaryOpsSchema0 {
  words?: boolean;
  nonwords?: boolean;
  overrides?: {
    [k: string]: boolean;
  };
}
type SpaceUnaryOpsRuleOptions = [SpaceUnaryOpsSchema0?];
//#endregion
//#region rules/spaced-comment/types.d.ts

type SpacedCommentSchema0 = 'always' | 'never';
interface SpacedCommentSchema1 {
  exceptions?: string[];
  markers?: string[];
  line?: {
    exceptions?: string[];
    markers?: string[];
  };
  block?: {
    exceptions?: string[];
    markers?: string[];
    balanced?: boolean;
  };
}
type SpacedCommentRuleOptions = [SpacedCommentSchema0?, SpacedCommentSchema1?];
//#endregion
//#region rules/switch-colon-spacing/types.d.ts

interface SwitchColonSpacingSchema0 {
  before?: boolean;
  after?: boolean;
}
type SwitchColonSpacingRuleOptions = [SwitchColonSpacingSchema0?];
//#endregion
//#region rules/template-curly-spacing/types.d.ts

type TemplateCurlySpacingSchema0 = 'always' | 'never';
type TemplateCurlySpacingRuleOptions = [TemplateCurlySpacingSchema0?];
//#endregion
//#region rules/template-tag-spacing/types.d.ts

type TemplateTagSpacingSchema0 = 'always' | 'never';
type TemplateTagSpacingRuleOptions = [TemplateTagSpacingSchema0?];
//#endregion
//#region rules/type-annotation-spacing/types.d.ts

interface TypeAnnotationSpacingSchema0 {
  before?: boolean;
  after?: boolean;
  overrides?: {
    colon?: SpacingConfig;
    arrow?: SpacingConfig;
    variable?: SpacingConfig;
    parameter?: SpacingConfig;
    property?: SpacingConfig;
    returnType?: SpacingConfig;
  };
}
interface SpacingConfig {
  before?: boolean;
  after?: boolean;
}
type TypeAnnotationSpacingRuleOptions = [TypeAnnotationSpacingSchema0?];
//#endregion
//#region rules/type-generic-spacing/types.d.ts

type TypeGenericSpacingRuleOptions = [];
//#endregion
//#region rules/type-named-tuple-spacing/types.d.ts

type TypeNamedTupleSpacingRuleOptions = [];
//#endregion
//#region rules/wrap-iife/types.d.ts

type WrapIifeSchema0 = 'outside' | 'inside' | 'any';
interface WrapIifeSchema1 {
  functionPrototypeMethods?: boolean;
}
type WrapIifeRuleOptions = [WrapIifeSchema0?, WrapIifeSchema1?];
//#endregion
//#region rules/wrap-regex/types.d.ts

type WrapRegexRuleOptions = [];
//#endregion
//#region rules/yield-star-spacing/types.d.ts

type YieldStarSpacingSchema0 = ('before' | 'after' | 'both' | 'neither') | {
  before?: boolean;
  after?: boolean;
};
type YieldStarSpacingRuleOptions = [YieldStarSpacingSchema0?];
//#endregion
//#region dts/rule-options.d.ts
interface RuleOptions {
  /**
   * Enforce linebreaks after opening and before closing array brackets
   * @see https://eslint.style/rules/array-bracket-newline
   */
  '@stylistic/array-bracket-newline': ArrayBracketNewlineRuleOptions;
  /**
   * Enforce consistent spacing inside array brackets
   * @see https://eslint.style/rules/array-bracket-spacing
   */
  '@stylistic/array-bracket-spacing': ArrayBracketSpacingRuleOptions;
  /**
   * Enforce line breaks after each array element
   * @see https://eslint.style/rules/array-element-newline
   */
  '@stylistic/array-element-newline': ArrayElementNewlineRuleOptions;
  /**
   * Require parentheses around arrow function arguments
   * @see https://eslint.style/rules/arrow-parens
   */
  '@stylistic/arrow-parens': ArrowParensRuleOptions;
  /**
   * Enforce consistent spacing before and after the arrow in arrow functions
   * @see https://eslint.style/rules/arrow-spacing
   */
  '@stylistic/arrow-spacing': ArrowSpacingRuleOptions;
  /**
   * Disallow or enforce spaces inside of blocks after opening block and before closing block
   * @see https://eslint.style/rules/block-spacing
   */
  '@stylistic/block-spacing': BlockSpacingRuleOptions;
  /**
   * Enforce consistent brace style for blocks
   * @see https://eslint.style/rules/brace-style
   */
  '@stylistic/brace-style': BraceStyleRuleOptions;
  /**
   * Require or disallow trailing commas
   * @see https://eslint.style/rules/comma-dangle
   */
  '@stylistic/comma-dangle': CommaDangleRuleOptions;
  /**
   * Enforce consistent spacing before and after commas
   * @see https://eslint.style/rules/comma-spacing
   */
  '@stylistic/comma-spacing': CommaSpacingRuleOptions;
  /**
   * Enforce consistent comma style
   * @see https://eslint.style/rules/comma-style
   */
  '@stylistic/comma-style': CommaStyleRuleOptions;
  /**
   * Enforce consistent spacing inside computed property brackets
   * @see https://eslint.style/rules/computed-property-spacing
   */
  '@stylistic/computed-property-spacing': ComputedPropertySpacingRuleOptions;
  /**
   * Enforce consistent line breaks after opening and before closing braces
   * @see https://eslint.style/rules/curly-newline
   */
  '@stylistic/curly-newline': CurlyNewlineRuleOptions;
  /**
   * Enforce consistent newlines before and after dots
   * @see https://eslint.style/rules/dot-location
   */
  '@stylistic/dot-location': DotLocationRuleOptions;
  /**
   * Require or disallow newline at the end of files
   * @see https://eslint.style/rules/eol-last
   */
  '@stylistic/eol-last': EolLastRuleOptions;
  /**
   * Enforce line breaks between arguments of a function call
   * @see https://eslint.style/rules/function-call-argument-newline
   */
  '@stylistic/function-call-argument-newline': FunctionCallArgumentNewlineRuleOptions;
  /**
   * Require or disallow spacing between function identifiers and their invocations
   * @see https://eslint.style/rules/function-call-spacing
   */
  '@stylistic/function-call-spacing': FunctionCallSpacingRuleOptions;
  /**
   * Enforce consistent line breaks inside function parentheses
   * @see https://eslint.style/rules/function-paren-newline
   */
  '@stylistic/function-paren-newline': FunctionParenNewlineRuleOptions;
  /**
   * Enforce consistent spacing around `*` operators in generator functions
   * @see https://eslint.style/rules/generator-star-spacing
   */
  '@stylistic/generator-star-spacing': GeneratorStarSpacingRuleOptions;
  /**
   * Enforce the location of arrow function bodies
   * @see https://eslint.style/rules/implicit-arrow-linebreak
   */
  '@stylistic/implicit-arrow-linebreak': ImplicitArrowLinebreakRuleOptions;
  /**
   * Enforce consistent indentation
   * @see https://eslint.style/rules/indent
   */
  '@stylistic/indent': IndentRuleOptions;
  /**
   * Indentation for binary operators
   * @see https://eslint.style/rules/indent-binary-ops
   */
  '@stylistic/indent-binary-ops': IndentBinaryOpsRuleOptions;
  /**
   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
   * @see https://eslint.style/rules/jsx-child-element-spacing
   */
  '@stylistic/jsx-child-element-spacing': JsxChildElementSpacingRuleOptions;
  /**
   * Enforce closing bracket location in JSX
   * @see https://eslint.style/rules/jsx-closing-bracket-location
   */
  '@stylistic/jsx-closing-bracket-location': JsxClosingBracketLocationRuleOptions;
  /**
   * Enforce closing tag location for multiline JSX
   * @see https://eslint.style/rules/jsx-closing-tag-location
   */
  '@stylistic/jsx-closing-tag-location': JsxClosingTagLocationRuleOptions;
  /**
   * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
   * @see https://eslint.style/rules/jsx-curly-brace-presence
   */
  '@stylistic/jsx-curly-brace-presence': JsxCurlyBracePresenceRuleOptions;
  /**
   * Enforce consistent linebreaks in curly braces in JSX attributes and expressions
   * @see https://eslint.style/rules/jsx-curly-newline
   */
  '@stylistic/jsx-curly-newline': JsxCurlyNewlineRuleOptions;
  /**
   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
   * @see https://eslint.style/rules/jsx-curly-spacing
   */
  '@stylistic/jsx-curly-spacing': JsxCurlySpacingRuleOptions;
  /**
   * Enforce or disallow spaces around equal signs in JSX attributes
   * @see https://eslint.style/rules/jsx-equals-spacing
   */
  '@stylistic/jsx-equals-spacing': JsxEqualsSpacingRuleOptions;
  /**
   * Enforce proper position of the first property in JSX
   * @see https://eslint.style/rules/jsx-first-prop-new-line
   */
  '@stylistic/jsx-first-prop-new-line': JsxFirstPropNewLineRuleOptions;
  /**
   * Enforce line breaks before and after JSX elements when they are used as arguments to a function.
   * @see https://eslint.style/rules/jsx-function-call-newline
   */
  '@stylistic/jsx-function-call-newline': JsxFunctionCallNewlineRuleOptions;
  /**
   * Enforce JSX indentation. Deprecated, use `indent` rule instead.
   * @see https://eslint.style/rules/jsx-indent
   */
  '@stylistic/jsx-indent': JsxIndentRuleOptions;
  /**
   * Enforce props indentation in JSX
   * @see https://eslint.style/rules/jsx-indent-props
   */
  '@stylistic/jsx-indent-props': JsxIndentPropsRuleOptions;
  /**
   * Enforce maximum of props on a single line in JSX
   * @see https://eslint.style/rules/jsx-max-props-per-line
   */
  '@stylistic/jsx-max-props-per-line': JsxMaxPropsPerLineRuleOptions;
  /**
   * Require or prevent a new line after jsx elements and expressions.
   * @see https://eslint.style/rules/jsx-newline
   */
  '@stylistic/jsx-newline': JsxNewlineRuleOptions;
  /**
   * Require one JSX element per line
   * @see https://eslint.style/rules/jsx-one-expression-per-line
   */
  '@stylistic/jsx-one-expression-per-line': JsxOneExpressionPerLineRuleOptions;
  /**
   * Enforce PascalCase for user-defined JSX components
   * @see https://eslint.style/rules/jsx-pascal-case
   */
  '@stylistic/jsx-pascal-case': JsxPascalCaseRuleOptions;
  /**
   * Disallow multiple spaces between inline JSX props. Deprecated, use `no-multi-spaces` rule instead.
   * @see https://eslint.style/rules/jsx-props-no-multi-spaces
   */
  '@stylistic/jsx-props-no-multi-spaces': JsxPropsNoMultiSpacesRuleOptions;
  /**
   * Enforce the consistent use of either double or single quotes in JSX attributes
   * @see https://eslint.style/rules/jsx-quotes
   */
  '@stylistic/jsx-quotes': JsxQuotesRuleOptions;
  /**
   * Disallow extra closing tags for components without children
   * @see https://eslint.style/rules/jsx-self-closing-comp
   */
  '@stylistic/jsx-self-closing-comp': JsxSelfClosingCompRuleOptions;
  /**
   * Enforce props alphabetical sorting
   * @see https://eslint.style/rules/jsx-sort-props
   */
  '@stylistic/jsx-sort-props': JsxSortPropsRuleOptions;
  /**
   * Enforce whitespace in and around the JSX opening and closing brackets
   * @see https://eslint.style/rules/jsx-tag-spacing
   */
  '@stylistic/jsx-tag-spacing': JsxTagSpacingRuleOptions;
  /**
   * Disallow missing parentheses around multiline JSX
   * @see https://eslint.style/rules/jsx-wrap-multilines
   */
  '@stylistic/jsx-wrap-multilines': JsxWrapMultilinesRuleOptions;
  /**
   * Enforce consistent spacing between property names and type annotations in types and interfaces
   * @see https://eslint.style/rules/key-spacing
   */
  '@stylistic/key-spacing': KeySpacingRuleOptions;
  /**
   * Enforce consistent spacing before and after keywords
   * @see https://eslint.style/rules/keyword-spacing
   */
  '@stylistic/keyword-spacing': KeywordSpacingRuleOptions;
  /**
   * Enforce position of line comments
   * @see https://eslint.style/rules/line-comment-position
   */
  '@stylistic/line-comment-position': LineCommentPositionRuleOptions;
  /**
   * Enforce consistent linebreak style
   * @see https://eslint.style/rules/linebreak-style
   */
  '@stylistic/linebreak-style': LinebreakStyleRuleOptions;
  /**
   * Require empty lines around comments
   * @see https://eslint.style/rules/lines-around-comment
   */
  '@stylistic/lines-around-comment': LinesAroundCommentRuleOptions;
  /**
   * Require or disallow an empty line between class members
   * @see https://eslint.style/rules/lines-between-class-members
   */
  '@stylistic/lines-between-class-members': LinesBetweenClassMembersRuleOptions;
  /**
   * Enforce a maximum line length
   * @see https://eslint.style/rules/max-len
   */
  '@stylistic/max-len': MaxLenRuleOptions;
  /**
   * Enforce a maximum number of statements allowed per line
   * @see https://eslint.style/rules/max-statements-per-line
   */
  '@stylistic/max-statements-per-line': MaxStatementsPerLineRuleOptions;
  /**
   * Require a specific member delimiter style for interfaces and type literals
   * @see https://eslint.style/rules/member-delimiter-style
   */
  '@stylistic/member-delimiter-style': MemberDelimiterStyleRuleOptions;
  /**
   * Enforce a particular style for multiline comments
   * @see https://eslint.style/rules/multiline-comment-style
   */
  '@stylistic/multiline-comment-style': MultilineCommentStyleRuleOptions;
  /**
   * Enforce newlines between operands of ternary expressions
   * @see https://eslint.style/rules/multiline-ternary
   */
  '@stylistic/multiline-ternary': MultilineTernaryRuleOptions;
  /**
   * Enforce or disallow parentheses when invoking a constructor with no arguments
   * @see https://eslint.style/rules/new-parens
   */
  '@stylistic/new-parens': NewParensRuleOptions;
  /**
   * Require a newline after each call in a method chain
   * @see https://eslint.style/rules/newline-per-chained-call
   */
  '@stylistic/newline-per-chained-call': NewlinePerChainedCallRuleOptions;
  /**
   * Disallow arrow functions where they could be confused with comparisons
   * @see https://eslint.style/rules/no-confusing-arrow
   */
  '@stylistic/no-confusing-arrow': NoConfusingArrowRuleOptions;
  /**
   * Disallow unnecessary parentheses
   * @see https://eslint.style/rules/no-extra-parens
   */
  '@stylistic/no-extra-parens': NoExtraParensRuleOptions;
  /**
   * Disallow unnecessary semicolons
   * @see https://eslint.style/rules/no-extra-semi
   */
  '@stylistic/no-extra-semi': NoExtraSemiRuleOptions;
  /**
   * Disallow leading or trailing decimal points in numeric literals
   * @see https://eslint.style/rules/no-floating-decimal
   */
  '@stylistic/no-floating-decimal': NoFloatingDecimalRuleOptions;
  /**
   * Disallow mixed binary operators
   * @see https://eslint.style/rules/no-mixed-operators
   */
  '@stylistic/no-mixed-operators': NoMixedOperatorsRuleOptions;
  /**
   * Disallow mixed spaces and tabs for indentation
   * @see https://eslint.style/rules/no-mixed-spaces-and-tabs
   */
  '@stylistic/no-mixed-spaces-and-tabs': NoMixedSpacesAndTabsRuleOptions;
  /**
   * Disallow multiple spaces
   * @see https://eslint.style/rules/no-multi-spaces
   */
  '@stylistic/no-multi-spaces': NoMultiSpacesRuleOptions;
  /**
   * Disallow multiple empty lines
   * @see https://eslint.style/rules/no-multiple-empty-lines
   */
  '@stylistic/no-multiple-empty-lines': NoMultipleEmptyLinesRuleOptions;
  /**
   * Disallow all tabs
   * @see https://eslint.style/rules/no-tabs
   */
  '@stylistic/no-tabs': NoTabsRuleOptions;
  /**
   * Disallow trailing whitespace at the end of lines
   * @see https://eslint.style/rules/no-trailing-spaces
   */
  '@stylistic/no-trailing-spaces': NoTrailingSpacesRuleOptions;
  /**
   * Disallow whitespace before properties
   * @see https://eslint.style/rules/no-whitespace-before-property
   */
  '@stylistic/no-whitespace-before-property': NoWhitespaceBeforePropertyRuleOptions;
  /**
   * Enforce the location of single-line statements
   * @see https://eslint.style/rules/nonblock-statement-body-position
   */
  '@stylistic/nonblock-statement-body-position': NonblockStatementBodyPositionRuleOptions;
  /**
   * Enforce consistent line breaks after opening and before closing braces
   * @see https://eslint.style/rules/object-curly-newline
   */
  '@stylistic/object-curly-newline': ObjectCurlyNewlineRuleOptions;
  /**
   * Enforce consistent spacing inside braces
   * @see https://eslint.style/rules/object-curly-spacing
   */
  '@stylistic/object-curly-spacing': ObjectCurlySpacingRuleOptions;
  /**
   * Enforce placing object properties on separate lines
   * @see https://eslint.style/rules/object-property-newline
   */
  '@stylistic/object-property-newline': ObjectPropertyNewlineRuleOptions;
  /**
   * Require or disallow newlines around variable declarations
   * @see https://eslint.style/rules/one-var-declaration-per-line
   */
  '@stylistic/one-var-declaration-per-line': OneVarDeclarationPerLineRuleOptions;
  /**
   * Enforce consistent linebreak style for operators
   * @see https://eslint.style/rules/operator-linebreak
   */
  '@stylistic/operator-linebreak': OperatorLinebreakRuleOptions;
  /**
   * Require or disallow padding within blocks
   * @see https://eslint.style/rules/padded-blocks
   */
  '@stylistic/padded-blocks': PaddedBlocksRuleOptions;
  /**
   * Require or disallow padding lines between statements
   * @see https://eslint.style/rules/padding-line-between-statements
   */
  '@stylistic/padding-line-between-statements': PaddingLineBetweenStatementsRuleOptions;
  /**
   * Require quotes around object literal, type literal, interfaces and enums property names
   * @see https://eslint.style/rules/quote-props
   */
  '@stylistic/quote-props': QuotePropsRuleOptions;
  /**
   * Enforce the consistent use of either backticks, double, or single quotes
   * @see https://eslint.style/rules/quotes
   */
  '@stylistic/quotes': QuotesRuleOptions;
  /**
   * Enforce spacing between rest and spread operators and their expressions
   * @see https://eslint.style/rules/rest-spread-spacing
   */
  '@stylistic/rest-spread-spacing': RestSpreadSpacingRuleOptions;
  /**
   * Require or disallow semicolons instead of ASI
   * @see https://eslint.style/rules/semi
   */
  '@stylistic/semi': SemiRuleOptions;
  /**
   * Enforce consistent spacing before and after semicolons
   * @see https://eslint.style/rules/semi-spacing
   */
  '@stylistic/semi-spacing': SemiSpacingRuleOptions;
  /**
   * Enforce location of semicolons
   * @see https://eslint.style/rules/semi-style
   */
  '@stylistic/semi-style': SemiStyleRuleOptions;
  /**
   * Enforce consistent spacing before blocks
   * @see https://eslint.style/rules/space-before-blocks
   */
  '@stylistic/space-before-blocks': SpaceBeforeBlocksRuleOptions;
  /**
   * Enforce consistent spacing before function parenthesis
   * @see https://eslint.style/rules/space-before-function-paren
   */
  '@stylistic/space-before-function-paren': SpaceBeforeFunctionParenRuleOptions;
  /**
   * Enforce consistent spacing inside parentheses
   * @see https://eslint.style/rules/space-in-parens
   */
  '@stylistic/space-in-parens': SpaceInParensRuleOptions;
  /**
   * Require spacing around infix operators
   * @see https://eslint.style/rules/space-infix-ops
   */
  '@stylistic/space-infix-ops': SpaceInfixOpsRuleOptions;
  /**
   * Enforce consistent spacing before or after unary operators
   * @see https://eslint.style/rules/space-unary-ops
   */
  '@stylistic/space-unary-ops': SpaceUnaryOpsRuleOptions;
  /**
   * Enforce consistent spacing after the `//` or `/*` in a comment
   * @see https://eslint.style/rules/spaced-comment
   */
  '@stylistic/spaced-comment': SpacedCommentRuleOptions;
  /**
   * Enforce spacing around colons of switch statements
   * @see https://eslint.style/rules/switch-colon-spacing
   */
  '@stylistic/switch-colon-spacing': SwitchColonSpacingRuleOptions;
  /**
   * Require or disallow spacing around embedded expressions of template strings
   * @see https://eslint.style/rules/template-curly-spacing
   */
  '@stylistic/template-curly-spacing': TemplateCurlySpacingRuleOptions;
  /**
   * Require or disallow spacing between template tags and their literals
   * @see https://eslint.style/rules/template-tag-spacing
   */
  '@stylistic/template-tag-spacing': TemplateTagSpacingRuleOptions;
  /**
   * Require consistent spacing around type annotations
   * @see https://eslint.style/rules/type-annotation-spacing
   */
  '@stylistic/type-annotation-spacing': TypeAnnotationSpacingRuleOptions;
  /**
   * Enforces consistent spacing inside TypeScript type generics
   * @see https://eslint.style/rules/type-generic-spacing
   */
  '@stylistic/type-generic-spacing': TypeGenericSpacingRuleOptions;
  /**
   * Expect space before the type declaration in the named tuple
   * @see https://eslint.style/rules/type-named-tuple-spacing
   */
  '@stylistic/type-named-tuple-spacing': TypeNamedTupleSpacingRuleOptions;
  /**
   * Require parentheses around immediate `function` invocations
   * @see https://eslint.style/rules/wrap-iife
   */
  '@stylistic/wrap-iife': WrapIifeRuleOptions;
  /**
   * Require parenthesis around regex literals
   * @see https://eslint.style/rules/wrap-regex
   */
  '@stylistic/wrap-regex': WrapRegexRuleOptions;
  /**
   * Require or disallow spacing around the `*` in `yield*` expressions
   * @see https://eslint.style/rules/yield-star-spacing
   */
  '@stylistic/yield-star-spacing': YieldStarSpacingRuleOptions;
}
interface UnprefixedRuleOptions {
  /**
   * Enforce linebreaks after opening and before closing array brackets
   * @see https://eslint.style/rules/array-bracket-newline
   */
  'array-bracket-newline': ArrayBracketNewlineRuleOptions;
  /**
   * Enforce consistent spacing inside array brackets
   * @see https://eslint.style/rules/array-bracket-spacing
   */
  'array-bracket-spacing': ArrayBracketSpacingRuleOptions;
  /**
   * Enforce line breaks after each array element
   * @see https://eslint.style/rules/array-element-newline
   */
  'array-element-newline': ArrayElementNewlineRuleOptions;
  /**
   * Require parentheses around arrow function arguments
   * @see https://eslint.style/rules/arrow-parens
   */
  'arrow-parens': ArrowParensRuleOptions;
  /**
   * Enforce consistent spacing before and after the arrow in arrow functions
   * @see https://eslint.style/rules/arrow-spacing
   */
  'arrow-spacing': ArrowSpacingRuleOptions;
  /**
   * Disallow or enforce spaces inside of blocks after opening block and before closing block
   * @see https://eslint.style/rules/block-spacing
   */
  'block-spacing': BlockSpacingRuleOptions;
  /**
   * Enforce consistent brace style for blocks
   * @see https://eslint.style/rules/brace-style
   */
  'brace-style': BraceStyleRuleOptions;
  /**
   * Require or disallow trailing commas
   * @see https://eslint.style/rules/comma-dangle
   */
  'comma-dangle': CommaDangleRuleOptions;
  /**
   * Enforce consistent spacing before and after commas
   * @see https://eslint.style/rules/comma-spacing
   */
  'comma-spacing': CommaSpacingRuleOptions;
  /**
   * Enforce consistent comma style
   * @see https://eslint.style/rules/comma-style
   */
  'comma-style': CommaStyleRuleOptions;
  /**
   * Enforce consistent spacing inside computed property brackets
   * @see https://eslint.style/rules/computed-property-spacing
   */
  'computed-property-spacing': ComputedPropertySpacingRuleOptions;
  /**
   * Enforce consistent line breaks after opening and before closing braces
   * @see https://eslint.style/rules/curly-newline
   */
  'curly-newline': CurlyNewlineRuleOptions;
  /**
   * Enforce consistent newlines before and after dots
   * @see https://eslint.style/rules/dot-location
   */
  'dot-location': DotLocationRuleOptions;
  /**
   * Require or disallow newline at the end of files
   * @see https://eslint.style/rules/eol-last
   */
  'eol-last': EolLastRuleOptions;
  /**
   * Enforce line breaks between arguments of a function call
   * @see https://eslint.style/rules/function-call-argument-newline
   */
  'function-call-argument-newline': FunctionCallArgumentNewlineRuleOptions;
  /**
   * Require or disallow spacing between function identifiers and their invocations
   * @see https://eslint.style/rules/function-call-spacing
   */
  'function-call-spacing': FunctionCallSpacingRuleOptions;
  /**
   * Enforce consistent line breaks inside function parentheses
   * @see https://eslint.style/rules/function-paren-newline
   */
  'function-paren-newline': FunctionParenNewlineRuleOptions;
  /**
   * Enforce consistent spacing around `*` operators in generator functions
   * @see https://eslint.style/rules/generator-star-spacing
   */
  'generator-star-spacing': GeneratorStarSpacingRuleOptions;
  /**
   * Enforce the location of arrow function bodies
   * @see https://eslint.style/rules/implicit-arrow-linebreak
   */
  'implicit-arrow-linebreak': ImplicitArrowLinebreakRuleOptions;
  /**
   * Enforce consistent indentation
   * @see https://eslint.style/rules/indent
   */
  'indent': IndentRuleOptions;
  /**
   * Indentation for binary operators
   * @see https://eslint.style/rules/indent-binary-ops
   */
  'indent-binary-ops': IndentBinaryOpsRuleOptions;
  /**
   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
   * @see https://eslint.style/rules/jsx-child-element-spacing
   */
  'jsx-child-element-spacing': JsxChildElementSpacingRuleOptions;
  /**
   * Enforce closing bracket location in JSX
   * @see https://eslint.style/rules/jsx-closing-bracket-location
   */
  'jsx-closing-bracket-location': JsxClosingBracketLocationRuleOptions;
  /**
   * Enforce closing tag location for multiline JSX
   * @see https://eslint.style/rules/jsx-closing-tag-location
   */
  'jsx-closing-tag-location': JsxClosingTagLocationRuleOptions;
  /**
   * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
   * @see https://eslint.style/rules/jsx-curly-brace-presence
   */
  'jsx-curly-brace-presence': JsxCurlyBracePresenceRuleOptions;
  /**
   * Enforce consistent linebreaks in curly braces in JSX attributes and expressions
   * @see https://eslint.style/rules/jsx-curly-newline
   */
  'jsx-curly-newline': JsxCurlyNewlineRuleOptions;
  /**
   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
   * @see https://eslint.style/rules/jsx-curly-spacing
   */
  'jsx-curly-spacing': JsxCurlySpacingRuleOptions;
  /**
   * Enforce or disallow spaces around equal signs in JSX attributes
   * @see https://eslint.style/rules/jsx-equals-spacing
   */
  'jsx-equals-spacing': JsxEqualsSpacingRuleOptions;
  /**
   * Enforce proper position of the first property in JSX
   * @see https://eslint.style/rules/jsx-first-prop-new-line
   */
  'jsx-first-prop-new-line': JsxFirstPropNewLineRuleOptions;
  /**
   * Enforce line breaks before and after JSX elements when they are used as arguments to a function.
   * @see https://eslint.style/rules/jsx-function-call-newline
   */
  'jsx-function-call-newline': JsxFunctionCallNewlineRuleOptions;
  /**
   * Enforce JSX indentation. Deprecated, use `indent` rule instead.
   * @see https://eslint.style/rules/jsx-indent
   */
  'jsx-indent': JsxIndentRuleOptions;
  /**
   * Enforce props indentation in JSX
   * @see https://eslint.style/rules/jsx-indent-props
   */
  'jsx-indent-props': JsxIndentPropsRuleOptions;
  /**
   * Enforce maximum of props on a single line in JSX
   * @see https://eslint.style/rules/jsx-max-props-per-line
   */
  'jsx-max-props-per-line': JsxMaxPropsPerLineRuleOptions;
  /**
   * Require or prevent a new line after jsx elements and expressions.
   * @see https://eslint.style/rules/jsx-newline
   */
  'jsx-newline': JsxNewlineRuleOptions;
  /**
   * Require one JSX element per line
   * @see https://eslint.style/rules/jsx-one-expression-per-line
   */
  'jsx-one-expression-per-line': JsxOneExpressionPerLineRuleOptions;
  /**
   * Enforce PascalCase for user-defined JSX components
   * @see https://eslint.style/rules/jsx-pascal-case
   */
  'jsx-pascal-case': JsxPascalCaseRuleOptions;
  /**
   * Disallow multiple spaces between inline JSX props. Deprecated, use `no-multi-spaces` rule instead.
   * @see https://eslint.style/rules/jsx-props-no-multi-spaces
   */
  'jsx-props-no-multi-spaces': JsxPropsNoMultiSpacesRuleOptions;
  /**
   * Enforce the consistent use of either double or single quotes in JSX attributes
   * @see https://eslint.style/rules/jsx-quotes
   */
  'jsx-quotes': JsxQuotesRuleOptions;
  /**
   * Disallow extra closing tags for components without children
   * @see https://eslint.style/rules/jsx-self-closing-comp
   */
  'jsx-self-closing-comp': JsxSelfClosingCompRuleOptions;
  /**
   * Enforce props alphabetical sorting
   * @see https://eslint.style/rules/jsx-sort-props
   */
  'jsx-sort-props': JsxSortPropsRuleOptions;
  /**
   * Enforce whitespace in and around the JSX opening and closing brackets
   * @see https://eslint.style/rules/jsx-tag-spacing
   */
  'jsx-tag-spacing': JsxTagSpacingRuleOptions;
  /**
   * Disallow missing parentheses around multiline JSX
   * @see https://eslint.style/rules/jsx-wrap-multilines
   */
  'jsx-wrap-multilines': JsxWrapMultilinesRuleOptions;
  /**
   * Enforce consistent spacing between property names and type annotations in types and interfaces
   * @see https://eslint.style/rules/key-spacing
   */
  'key-spacing': KeySpacingRuleOptions;
  /**
   * Enforce consistent spacing before and after keywords
   * @see https://eslint.style/rules/keyword-spacing
   */
  'keyword-spacing': KeywordSpacingRuleOptions;
  /**
   * Enforce position of line comments
   * @see https://eslint.style/rules/line-comment-position
   */
  'line-comment-position': LineCommentPositionRuleOptions;
  /**
   * Enforce consistent linebreak style
   * @see https://eslint.style/rules/linebreak-style
   */
  'linebreak-style': LinebreakStyleRuleOptions;
  /**
   * Require empty lines around comments
   * @see https://eslint.style/rules/lines-around-comment
   */
  'lines-around-comment': LinesAroundCommentRuleOptions;
  /**
   * Require or disallow an empty line between class members
   * @see https://eslint.style/rules/lines-between-class-members
   */
  'lines-between-class-members': LinesBetweenClassMembersRuleOptions;
  /**
   * Enforce a maximum line length
   * @see https://eslint.style/rules/max-len
   */
  'max-len': MaxLenRuleOptions;
  /**
   * Enforce a maximum number of statements allowed per line
   * @see https://eslint.style/rules/max-statements-per-line
   */
  'max-statements-per-line': MaxStatementsPerLineRuleOptions;
  /**
   * Require a specific member delimiter style for interfaces and type literals
   * @see https://eslint.style/rules/member-delimiter-style
   */
  'member-delimiter-style': MemberDelimiterStyleRuleOptions;
  /**
   * Enforce a particular style for multiline comments
   * @see https://eslint.style/rules/multiline-comment-style
   */
  'multiline-comment-style': MultilineCommentStyleRuleOptions;
  /**
   * Enforce newlines between operands of ternary expressions
   * @see https://eslint.style/rules/multiline-ternary
   */
  'multiline-ternary': MultilineTernaryRuleOptions;
  /**
   * Enforce or disallow parentheses when invoking a constructor with no arguments
   * @see https://eslint.style/rules/new-parens
   */
  'new-parens': NewParensRuleOptions;
  /**
   * Require a newline after each call in a method chain
   * @see https://eslint.style/rules/newline-per-chained-call
   */
  'newline-per-chained-call': NewlinePerChainedCallRuleOptions;
  /**
   * Disallow arrow functions where they could be confused with comparisons
   * @see https://eslint.style/rules/no-confusing-arrow
   */
  'no-confusing-arrow': NoConfusingArrowRuleOptions;
  /**
   * Disallow unnecessary parentheses
   * @see https://eslint.style/rules/no-extra-parens
   */
  'no-extra-parens': NoExtraParensRuleOptions;
  /**
   * Disallow unnecessary semicolons
   * @see https://eslint.style/rules/no-extra-semi
   */
  'no-extra-semi': NoExtraSemiRuleOptions;
  /**
   * Disallow leading or trailing decimal points in numeric literals
   * @see https://eslint.style/rules/no-floating-decimal
   */
  'no-floating-decimal': NoFloatingDecimalRuleOptions;
  /**
   * Disallow mixed binary operators
   * @see https://eslint.style/rules/no-mixed-operators
   */
  'no-mixed-operators': NoMixedOperatorsRuleOptions;
  /**
   * Disallow mixed spaces and tabs for indentation
   * @see https://eslint.style/rules/no-mixed-spaces-and-tabs
   */
  'no-mixed-spaces-and-tabs': NoMixedSpacesAndTabsRuleOptions;
  /**
   * Disallow multiple spaces
   * @see https://eslint.style/rules/no-multi-spaces
   */
  'no-multi-spaces': NoMultiSpacesRuleOptions;
  /**
   * Disallow multiple empty lines
   * @see https://eslint.style/rules/no-multiple-empty-lines
   */
  'no-multiple-empty-lines': NoMultipleEmptyLinesRuleOptions;
  /**
   * Disallow all tabs
   * @see https://eslint.style/rules/no-tabs
   */
  'no-tabs': NoTabsRuleOptions;
  /**
   * Disallow trailing whitespace at the end of lines
   * @see https://eslint.style/rules/no-trailing-spaces
   */
  'no-trailing-spaces': NoTrailingSpacesRuleOptions;
  /**
   * Disallow whitespace before properties
   * @see https://eslint.style/rules/no-whitespace-before-property
   */
  'no-whitespace-before-property': NoWhitespaceBeforePropertyRuleOptions;
  /**
   * Enforce the location of single-line statements
   * @see https://eslint.style/rules/nonblock-statement-body-position
   */
  'nonblock-statement-body-position': NonblockStatementBodyPositionRuleOptions;
  /**
   * Enforce consistent line breaks after opening and before closing braces
   * @see https://eslint.style/rules/object-curly-newline
   */
  'object-curly-newline': ObjectCurlyNewlineRuleOptions;
  /**
   * Enforce consistent spacing inside braces
   * @see https://eslint.style/rules/object-curly-spacing
   */
  'object-curly-spacing': ObjectCurlySpacingRuleOptions;
  /**
   * Enforce placing object properties on separate lines
   * @see https://eslint.style/rules/object-property-newline
   */
  'object-property-newline': ObjectPropertyNewlineRuleOptions;
  /**
   * Require or disallow newlines around variable declarations
   * @see https://eslint.style/rules/one-var-declaration-per-line
   */
  'one-var-declaration-per-line': OneVarDeclarationPerLineRuleOptions;
  /**
   * Enforce consistent linebreak style for operators
   * @see https://eslint.style/rules/operator-linebreak
   */
  'operator-linebreak': OperatorLinebreakRuleOptions;
  /**
   * Require or disallow padding within blocks
   * @see https://eslint.style/rules/padded-blocks
   */
  'padded-blocks': PaddedBlocksRuleOptions;
  /**
   * Require or disallow padding lines between statements
   * @see https://eslint.style/rules/padding-line-between-statements
   */
  'padding-line-between-statements': PaddingLineBetweenStatementsRuleOptions;
  /**
   * Require quotes around object literal, type literal, interfaces and enums property names
   * @see https://eslint.style/rules/quote-props
   */
  'quote-props': QuotePropsRuleOptions;
  /**
   * Enforce the consistent use of either backticks, double, or single quotes
   * @see https://eslint.style/rules/quotes
   */
  'quotes': QuotesRuleOptions;
  /**
   * Enforce spacing between rest and spread operators and their expressions
   * @see https://eslint.style/rules/rest-spread-spacing
   */
  'rest-spread-spacing': RestSpreadSpacingRuleOptions;
  /**
   * Require or disallow semicolons instead of ASI
   * @see https://eslint.style/rules/semi
   */
  'semi': SemiRuleOptions;
  /**
   * Enforce consistent spacing before and after semicolons
   * @see https://eslint.style/rules/semi-spacing
   */
  'semi-spacing': SemiSpacingRuleOptions;
  /**
   * Enforce location of semicolons
   * @see https://eslint.style/rules/semi-style
   */
  'semi-style': SemiStyleRuleOptions;
  /**
   * Enforce consistent spacing before blocks
   * @see https://eslint.style/rules/space-before-blocks
   */
  'space-before-blocks': SpaceBeforeBlocksRuleOptions;
  /**
   * Enforce consistent spacing before function parenthesis
   * @see https://eslint.style/rules/space-before-function-paren
   */
  'space-before-function-paren': SpaceBeforeFunctionParenRuleOptions;
  /**
   * Enforce consistent spacing inside parentheses
   * @see https://eslint.style/rules/space-in-parens
   */
  'space-in-parens': SpaceInParensRuleOptions;
  /**
   * Require spacing around infix operators
   * @see https://eslint.style/rules/space-infix-ops
   */
  'space-infix-ops': SpaceInfixOpsRuleOptions;
  /**
   * Enforce consistent spacing before or after unary operators
   * @see https://eslint.style/rules/space-unary-ops
   */
  'space-unary-ops': SpaceUnaryOpsRuleOptions;
  /**
   * Enforce consistent spacing after the `//` or `/*` in a comment
   * @see https://eslint.style/rules/spaced-comment
   */
  'spaced-comment': SpacedCommentRuleOptions;
  /**
   * Enforce spacing around colons of switch statements
   * @see https://eslint.style/rules/switch-colon-spacing
   */
  'switch-colon-spacing': SwitchColonSpacingRuleOptions;
  /**
   * Require or disallow spacing around embedded expressions of template strings
   * @see https://eslint.style/rules/template-curly-spacing
   */
  'template-curly-spacing': TemplateCurlySpacingRuleOptions;
  /**
   * Require or disallow spacing between template tags and their literals
   * @see https://eslint.style/rules/template-tag-spacing
   */
  'template-tag-spacing': TemplateTagSpacingRuleOptions;
  /**
   * Require consistent spacing around type annotations
   * @see https://eslint.style/rules/type-annotation-spacing
   */
  'type-annotation-spacing': TypeAnnotationSpacingRuleOptions;
  /**
   * Enforces consistent spacing inside TypeScript type generics
   * @see https://eslint.style/rules/type-generic-spacing
   */
  'type-generic-spacing': TypeGenericSpacingRuleOptions;
  /**
   * Expect space before the type declaration in the named tuple
   * @see https://eslint.style/rules/type-named-tuple-spacing
   */
  'type-named-tuple-spacing': TypeNamedTupleSpacingRuleOptions;
  /**
   * Require parentheses around immediate `function` invocations
   * @see https://eslint.style/rules/wrap-iife
   */
  'wrap-iife': WrapIifeRuleOptions;
  /**
   * Require parenthesis around regex literals
   * @see https://eslint.style/rules/wrap-regex
   */
  'wrap-regex': WrapRegexRuleOptions;
  /**
   * Require or disallow spacing around the `*` in `yield*` expressions
   * @see https://eslint.style/rules/yield-star-spacing
   */
  'yield-star-spacing': YieldStarSpacingRuleOptions;
}
//#endregion
export { RuleOptions, UnprefixedRuleOptions };