@systemfsoftware/stryker-js 17.0.2 → 22.0.0

package/dist/{index-y-Pg3XgT.d.mts → index-ClWSuUog.d.mts}

@@ -1,9 +1,9 @@
 import * as S from "effect/Schema";
-import * as Option$1 from "effect/Option";
-import * as Order from "effect/Order";
-import * as Context from "effect/Context";
 import { Schema } from "effect";
 import * as Effect$1 from "effect/Effect";
+import * as Option$1 from "effect/Option";
+import * as Order$1 from "effect/Order";
+import * as Context from "effect/Context";
 import * as Rpc from "effect/rpc/Rpc";
 import * as RpcGroup from "effect/rpc/RpcGroup";
 import * as RpcMiddleware from "effect/rpc/RpcMiddleware";
@@ -12,80 +12,241 @@ import * as HashMap from "effect/HashMap";
 import { StandardSchemaV1 } from "effect/StandardSchema";
 import * as RpcSchema from "effect/rpc/RpcSchema";
 //#region ../ignorers/interface/dist/index.d.ts
-declare interface AccessorProperty$1 extends Span$1 {
-  type: AccessorPropertyType;
-  decorators: Array<Decorator$1>;
-  key: PropertyKey_2;
-  typeAnnotation?: TSTypeAnnotation$1 | null;
-  value: Expression$1 | null;
-  computed: boolean;
-  static: boolean;
-  override?: boolean;
-  definite?: boolean;
-  accessibility?: TSAccessibility | null;
-  declare?: false;
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/typescript.rs`.
+interface Program$1 extends Span$1 {
+  type: "Program";
+  body: Array<Directive | Statement$1>;
+  sourceType: ModuleKind;
+  hashbang: Hashbang | null;
+  parent?: null;
+}
+type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
+interface IdentifierName$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
   optional?: false;
-  readonly?: false;
+  typeAnnotation?: null;
   parent?: Node$1;
 }
-declare type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty";
-declare type Argument$1 = SpreadElement$1 | Expression$1;
-declare interface ArrayAssignmentTarget extends Span$1 {
-  type: "ArrayPattern";
+interface IdentifierReference$1 extends Span$1 {
+  type: "Identifier";
   decorators?: [];
-  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+interface BindingIdentifier$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+interface LabelIdentifier$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
   optional?: false;
   typeAnnotation?: null;
   parent?: Node$1;
 }
-declare interface ArrayExpression$1 extends Span$1 {
+interface ThisExpression$1 extends Span$1 {
+  type: "ThisExpression";
+  parent?: Node$1;
+}
+interface ArrayExpression$1 extends Span$1 {
   type: "ArrayExpression";
   elements: Array<ArrayExpressionElement>;
   parent?: Node$1;
 }
-declare type ArrayExpressionElement = SpreadElement$1 | null | Expression$1;
-declare interface ArrayPattern$1 extends Span$1 {
-  type: "ArrayPattern";
-  decorators?: [];
-  elements: Array<BindingPattern$1 | BindingRestElement$1 | null>;
+type ArrayExpressionElement = SpreadElement$1 | null | Expression$1;
+interface ObjectExpression$1 extends Span$1 {
+  type: "ObjectExpression";
+  properties: Array<ObjectPropertyKind>;
+  parent?: Node$1;
+}
+type ObjectPropertyKind = ObjectProperty$1 | SpreadElement$1;
+interface ObjectProperty$1 extends Span$1 {
+  type: "Property";
+  kind: PropertyKind;
+  key: PropertyKey;
+  value: Expression$1;
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
   optional?: false;
-  typeAnnotation?: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare interface ArrowFunctionExpression$1 extends Span$1 {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  async: boolean;
-  typeParameters?: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType?: TSTypeAnnotation$1 | null;
-  body: FunctionBody | Expression$1;
-  id: null;
-  generator: false;
+type PropertyKey = IdentifierName$1 | PrivateIdentifier$1 | Expression$1;
+type PropertyKind = "init" | "get" | "set";
+interface TemplateLiteral$1 extends Span$1 {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement$1>;
+  expressions: Array<Expression$1>;
+  parent?: Node$1;
+}
+interface TaggedTemplateExpression$1 extends Span$1 {
+  type: "TaggedTemplateExpression";
+  tag: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  quasi: TemplateLiteral$1;
+  parent?: Node$1;
+}
+interface TemplateElement$1 extends Span$1 {
+  type: "TemplateElement";
+  value: TemplateElementValue;
+  tail: boolean;
+  parent?: Node$1;
+}
+interface TemplateElementValue {
+  raw: string;
+  cooked: string | null;
+}
+type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
+interface ComputedMemberExpression extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: Expression$1;
+  optional: boolean;
+  computed: true;
+  parent?: Node$1;
+}
+interface StaticMemberExpression$1 extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: IdentifierName$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1;
+}
+interface PrivateFieldExpression extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: PrivateIdentifier$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1;
+}
+interface CallExpression$1 extends Span$1 {
+  type: "CallExpression";
+  callee: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  arguments: Array<Argument$1>;
+  optional: boolean;
+  parent?: Node$1;
+}
+interface NewExpression$1 extends Span$1 {
+  type: "NewExpression";
+  callee: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  arguments: Array<Argument$1>;
+  parent?: Node$1;
+}
+interface MetaProperty$1 extends Span$1 {
+  type: "MetaProperty";
+  meta: IdentifierName$1;
+  property: IdentifierName$1;
+  parent?: Node$1;
+}
+interface SpreadElement$1 extends Span$1 {
+  type: "SpreadElement";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+type Argument$1 = SpreadElement$1 | Expression$1;
+interface UpdateExpression$1 extends Span$1 {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  prefix: boolean;
+  argument: SimpleAssignmentTarget$1;
+  parent?: Node$1;
+}
+interface UnaryExpression$1 extends Span$1 {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  argument: Expression$1;
+  prefix: true;
+  parent?: Node$1;
+}
+interface BinaryExpression$1 extends Span$1 {
+  type: "BinaryExpression";
+  left: Expression$1;
+  operator: BinaryOperator;
+  right: Expression$1;
+  parent?: Node$1;
+}
+interface PrivateInExpression$1 extends Span$1 {
+  type: "BinaryExpression";
+  left: PrivateIdentifier$1;
+  operator: "in";
+  right: Expression$1;
+  parent?: Node$1;
+}
+interface LogicalExpression$1 extends Span$1 {
+  type: "LogicalExpression";
+  left: Expression$1;
+  operator: LogicalOperator;
+  right: Expression$1;
+  parent?: Node$1;
+}
+interface ConditionalExpression$1 extends Span$1 {
+  type: "ConditionalExpression";
+  test: Expression$1;
+  consequent: Expression$1;
+  alternate: Expression$1;
   parent?: Node$1;
 }
-declare interface AssignmentExpression$1 extends Span$1 {
+interface AssignmentExpression$1 extends Span$1 {
   type: "AssignmentExpression";
   operator: AssignmentOperator;
   left: AssignmentTarget;
   right: Expression$1;
   parent?: Node$1;
 }
-declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-declare interface AssignmentPattern$1 extends Span$1 {
+type AssignmentTarget = SimpleAssignmentTarget$1 | AssignmentTargetPattern;
+type SimpleAssignmentTarget$1 = IdentifierReference$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1 | MemberExpression$1;
+type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
+interface ArrayAssignmentTarget extends Span$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+interface ObjectAssignmentTarget extends Span$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+interface AssignmentTargetRest extends Span$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: AssignmentTarget;
+  optional?: false;
+  typeAnnotation?: null;
+  value?: null;
+  parent?: Node$1;
+}
+type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget;
+interface AssignmentTargetWithDefault extends Span$1 {
   type: "AssignmentPattern";
   decorators?: [];
-  left: BindingPattern$1;
+  left: AssignmentTarget;
   right: Expression$1;
   optional?: false;
   typeAnnotation?: null;
   parent?: Node$1;
 }
-declare type AssignmentTarget = SimpleAssignmentTarget$1 | AssignmentTargetPattern;
-declare type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget;
-declare type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
-declare type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
-declare interface AssignmentTargetPropertyIdentifier extends Span$1 {
+type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
+interface AssignmentTargetPropertyIdentifier extends Span$1 {
   type: "Property";
   kind: "init";
   key: IdentifierReference$1;
@@ -96,10 +257,10 @@ declare interface AssignmentTargetPropertyIdentifier extends Span$1 {
   optional?: false;
   parent?: Node$1;
 }
-declare interface AssignmentTargetPropertyProperty extends Span$1 {
+interface AssignmentTargetPropertyProperty extends Span$1 {
   type: "Property";
   kind: "init";
-  key: PropertyKey_2;
+  key: PropertyKey;
   value: AssignmentTargetMaybeDefault;
   method: false;
   shorthand: false;
@@ -107,235 +268,111 @@ declare interface AssignmentTargetPropertyProperty extends Span$1 {
   optional?: false;
   parent?: Node$1;
 }
-declare interface AssignmentTargetRest extends Span$1 {
-  type: "RestElement";
-  decorators?: [];
-  argument: AssignmentTarget;
-  optional?: false;
-  typeAnnotation?: null;
-  value?: null;
+interface SequenceExpression$1 extends Span$1 {
+  type: "SequenceExpression";
+  expressions: Array<Expression$1>;
   parent?: Node$1;
 }
-declare interface AssignmentTargetWithDefault extends Span$1 {
-  type: "AssignmentPattern";
-  decorators?: [];
-  left: AssignmentTarget;
-  right: Expression$1;
-  optional?: false;
-  typeAnnotation?: null;
+interface Super$1 extends Span$1 {
+  type: "Super";
   parent?: Node$1;
 }
-declare interface AwaitExpression extends Span$1 {
+interface AwaitExpression extends Span$1 {
   type: "AwaitExpression";
   argument: Expression$1;
   parent?: Node$1;
 }
-declare interface BigIntLiteral$1 extends Span$1 {
-  type: "Literal";
-  value: bigint;
-  raw: string | null;
-  bigint: string;
-  parent?: Node$1;
-}
-declare interface BinaryExpression$1 extends Span$1 {
-  type: "BinaryExpression";
-  left: Expression$1;
-  operator: BinaryOperator;
-  right: Expression$1;
+interface ChainExpression$1 extends Span$1 {
+  type: "ChainExpression";
+  expression: ChainElement;
   parent?: Node$1;
 }
-declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
-declare interface BindingIdentifier$1 extends Span$1 {
-  type: "Identifier";
-  decorators?: [];
-  name: string;
-  optional?: false;
-  typeAnnotation?: TSTypeAnnotation$1 | null;
+type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
+interface ParenthesizedExpression extends Span$1 {
+  type: "ParenthesizedExpression";
+  expression: Expression$1;
   parent?: Node$1;
 }
-declare type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
-declare interface BindingProperty$1 extends Span$1 {
-  type: "Property";
-  kind: "init";
-  key: PropertyKey_2;
-  value: BindingPattern$1;
-  method: false;
-  shorthand: boolean;
-  computed: boolean;
-  optional?: false;
+type Statement$1 = BlockStatement$1 | BreakStatement$1 | ContinueStatement$1 | DebuggerStatement | DoWhileStatement$1 | EmptyStatement$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | IfStatement$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | WhileStatement$1 | WithStatement$1 | Declaration | ModuleDeclaration;
+interface Directive extends Span$1 {
+  type: "ExpressionStatement";
+  expression: StringLiteral$1;
+  directive: string;
   parent?: Node$1;
 }
-declare interface BindingRestElement$1 extends Span$1 {
-  type: "RestElement";
-  decorators?: [];
-  argument: BindingPattern$1;
-  optional?: false;
-  typeAnnotation?: TSTypeAnnotation$1 | null;
-  value?: null;
+interface Hashbang extends Span$1 {
+  type: "Hashbang";
+  value: string;
   parent?: Node$1;
 }
-declare interface BlockStatement$1 extends Span$1 {
+interface BlockStatement$1 extends Span$1 {
   type: "BlockStatement";
   body: Array<Statement$1>;
   parent?: Node$1;
 }
-declare interface BooleanLiteral$1 extends Span$1 {
-  type: "Literal";
-  value: boolean;
-  raw: string | null;
+type Declaration = VariableDeclaration$1 | Function$1 | Class$1 | TSTypeAliasDeclaration$1 | TSInterfaceDeclaration$1 | TSEnumDeclaration$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSImportEqualsDeclaration$1;
+interface VariableDeclaration$1 extends Span$1 {
+  type: "VariableDeclaration";
+  kind: VariableDeclarationKind;
+  declarations: Array<VariableDeclarator$1>;
+  declare?: boolean;
   parent?: Node$1;
 }
-declare interface BreakStatement$1 extends Span$1 {
-  type: "BreakStatement";
-  label: LabelIdentifier$1 | null;
+type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
+interface VariableDeclarator$1 extends Span$1 {
+  type: "VariableDeclarator";
+  id: BindingPattern$1;
+  init: Expression$1 | null;
+  definite?: boolean;
   parent?: Node$1;
 }
-declare type Built<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built<T[number]>> : T) : T extends Span$1 ? { [K in keyof T as K extends keyof Span$1 ? never : K]: Child<T[K]>; } & Partial<Pick<T, keyof Span$1>> : T;
-declare interface CallExpression$1 extends Span$1 {
-  type: "CallExpression";
-  callee: Expression$1;
-  typeArguments?: TSTypeParameterInstantiation$1 | null;
-  arguments: Array<Argument$1>;
-  optional: boolean;
-  parent?: Node$1;
-}
-declare interface CatchClause$1 extends Span$1 {
-  type: "CatchClause";
-  param: BindingPattern$1 | null;
-  body: BlockStatement$1;
-  parent?: Node$1;
-}
-declare type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
-declare interface ChainExpression$1 extends Span$1 {
-  type: "ChainExpression";
-  expression: ChainElement;
-  parent?: Node$1;
-}
-declare type Child<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child<T[number]>> : T) : T extends Span$1 ? Built<T> | T : T;
-declare interface Class$1 extends Span$1 {
-  type: ClassType;
-  decorators: Array<Decorator$1>;
-  id: BindingIdentifier$1 | null;
-  typeParameters?: TSTypeParameterDeclaration$1 | null;
-  superClass: Expression$1 | null;
-  superTypeArguments?: TSTypeParameterInstantiation$1 | null;
-  implements?: Array<TSClassImplements>;
-  body: ClassBody$1;
-  abstract?: boolean;
-  declare?: boolean;
-  parent?: Node$1;
-}
-declare interface ClassBody$1 extends Span$1 {
-  type: "ClassBody";
-  body: Array<ClassElement>;
-  parent?: Node$1;
-}
-declare type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
-declare type ClassType = "ClassDeclaration" | "ClassExpression";
-declare interface ComputedMemberExpression extends Span$1 {
-  type: "MemberExpression";
-  object: Expression$1;
-  property: Expression$1;
-  optional: boolean;
-  computed: true;
-  parent?: Node$1;
-}
-declare interface ConditionalExpression$1 extends Span$1 {
-  type: "ConditionalExpression";
-  test: Expression$1;
-  consequent: Expression$1;
-  alternate: Expression$1;
-  parent?: Node$1;
-}
-declare interface ContinueStatement$1 extends Span$1 {
-  type: "ContinueStatement";
-  label: LabelIdentifier$1 | null;
-  parent?: Node$1;
-}
-declare interface DebuggerStatement extends Span$1 {
-  type: "DebuggerStatement";
+interface EmptyStatement$1 extends Span$1 {
+  type: "EmptyStatement";
   parent?: Node$1;
 }
-declare type Declaration = VariableDeclaration$1 | Function$1 | Class$1 | TSTypeAliasDeclaration$1 | TSInterfaceDeclaration$1 | TSEnumDeclaration$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSImportEqualsDeclaration$1;
-declare interface Decorator$1 extends Span$1 {
-  type: "Decorator";
+interface ExpressionStatement$1 extends Span$1 {
+  type: "ExpressionStatement";
   expression: Expression$1;
+  directive?: string | null;
   parent?: Node$1;
 }
-declare interface Directive extends Span$1 {
-  type: "ExpressionStatement";
-  expression: StringLiteral$1;
-  directive: string;
+interface IfStatement$1 extends Span$1 {
+  type: "IfStatement";
+  test: Expression$1;
+  consequent: Statement$1;
+  alternate: Statement$1 | null;
   parent?: Node$1;
 }
-declare interface DoWhileStatement$1 extends Span$1 {
+interface DoWhileStatement$1 extends Span$1 {
   type: "DoWhileStatement";
   body: Statement$1;
   test: Expression$1;
   parent?: Node$1;
 }
-declare interface EmptyStatement$1 extends Span$1 {
-  type: "EmptyStatement";
-  parent?: Node$1;
-}
-declare interface ExportAllDeclaration$1 extends Span$1 {
-  type: "ExportAllDeclaration";
-  exported: ModuleExportName | null;
-  source: StringLiteral$1;
-  attributes: Array<ImportAttribute$1>;
-  exportKind?: ImportOrExportKind;
-  parent?: Node$1;
-}
-declare interface ExportDefaultDeclaration$1 extends Span$1 {
-  type: "ExportDefaultDeclaration";
-  declaration: ExportDefaultDeclarationKind;
-  exportKind?: "value";
-  parent?: Node$1;
-}
-declare type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
-declare interface ExportNamedDeclaration$1 extends Span$1 {
-  type: "ExportNamedDeclaration";
-  declaration: Declaration | null;
-  specifiers: Array<ExportSpecifier>;
-  source: StringLiteral$1 | null;
-  exportKind?: ImportOrExportKind;
-  attributes: Array<ImportAttribute$1>;
-  parent?: Node$1;
-}
-declare interface ExportSpecifier extends Span$1 {
-  type: "ExportSpecifier";
-  local: ModuleExportName;
-  exported: ModuleExportName;
-  exportKind?: ImportOrExportKind;
+interface WhileStatement$1 extends Span$1 {
+  type: "WhileStatement";
+  test: Expression$1;
+  body: Statement$1;
   parent?: Node$1;
 }
-declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
-declare interface ExpressionStatement$1 extends Span$1 {
-  type: "ExpressionStatement";
-  expression: Expression$1;
-  directive?: string | null;
+interface ForStatement$1 extends Span$1 {
+  type: "ForStatement";
+  init: ForStatementInit | null;
+  test: Expression$1 | null;
+  update: Expression$1 | null;
+  body: Statement$1;
   parent?: Node$1;
 }
-declare interface ForInStatement$1 extends Span$1 {
+type ForStatementInit = VariableDeclaration$1 | Expression$1;
+interface ForInStatement$1 extends Span$1 {
   type: "ForInStatement";
   left: ForStatementLeft;
   right: Expression$1;
   body: Statement$1;
   parent?: Node$1;
 }
-declare type FormalParameter = {
-  decorators?: Array<Decorator$1>;
-} & BindingPattern$1;
-declare interface FormalParameterRest extends Span$1 {
-  type: "RestElement";
-  argument: BindingPattern$1;
-  decorators?: Array<Decorator$1>;
-  optional?: boolean;
-  typeAnnotation?: TSTypeAnnotation$1 | null;
-  value?: null;
-  parent?: Node$1;
-}
-declare interface ForOfStatement$1 extends Span$1 {
+type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
+interface ForOfStatement$1 extends Span$1 {
   type: "ForOfStatement";
   await: boolean;
   left: ForStatementLeft;
@@ -343,546 +380,475 @@ declare interface ForOfStatement$1 extends Span$1 {
   body: Statement$1;
   parent?: Node$1;
 }
-declare interface ForStatement$1 extends Span$1 {
-  type: "ForStatement";
-  init: ForStatementInit | null;
-  test: Expression$1 | null;
-  update: Expression$1 | null;
-  body: Statement$1;
-  parent?: Node$1;
-}
-declare type ForStatementInit = VariableDeclaration$1 | Expression$1;
-declare type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
-declare interface Function$1 extends Span$1 {
-  type: FunctionType;
-  id: BindingIdentifier$1 | null;
-  generator: boolean;
-  async: boolean;
-  declare?: boolean;
-  typeParameters?: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType?: TSTypeAnnotation$1 | null;
-  body: FunctionBody | null;
-  expression: false;
-  parent?: Node$1;
-}
-declare interface FunctionBody extends Span$1 {
-  type: "BlockStatement";
-  body: Array<Directive | Statement$1>;
-  parent?: Node$1;
-}
-declare type FunctionType = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
-declare interface Hashbang extends Span$1 {
-  type: "Hashbang";
-  value: string;
-  parent?: Node$1;
-}
-declare interface IdentifierName$1 extends Span$1 {
-  type: "Identifier";
-  decorators?: [];
-  name: string;
-  optional?: false;
-  typeAnnotation?: null;
-  parent?: Node$1;
-}
-declare interface IdentifierReference$1 extends Span$1 {
-  type: "Identifier";
-  decorators?: [];
-  name: string;
-  optional?: false;
-  typeAnnotation?: null;
-  parent?: Node$1;
-}
-declare interface IfStatement$1 extends Span$1 {
-  type: "IfStatement";
-  test: Expression$1;
-  consequent: Statement$1;
-  alternate: Statement$1 | null;
-  parent?: Node$1;
-}
-declare interface Ignorer {
-  readonly name: string;
-  shouldIgnore(node: Node_2, ancestors: readonly Node_2[]): string | undefined;
-}
-declare interface ImportAttribute$1 extends Span$1 {
-  type: "ImportAttribute";
-  key: ImportAttributeKey;
-  value: StringLiteral$1;
-  parent?: Node$1;
-}
-declare type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
-declare interface ImportDeclaration$1 extends Span$1 {
-  type: "ImportDeclaration";
-  specifiers: Array<ImportDeclarationSpecifier>;
-  source: StringLiteral$1;
-  phase: ImportPhase | null;
-  attributes: Array<ImportAttribute$1>;
-  importKind?: ImportOrExportKind;
-  parent?: Node$1;
-}
-declare type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
-declare interface ImportDefaultSpecifier extends Span$1 {
-  type: "ImportDefaultSpecifier";
-  local: BindingIdentifier$1;
-  parent?: Node$1;
-}
-declare interface ImportExpression$1 extends Span$1 {
-  type: "ImportExpression";
-  source: Expression$1;
-  options: Expression$1 | null;
-  phase: ImportPhase | null;
-  parent?: Node$1;
-}
-declare interface ImportNamespaceSpecifier extends Span$1 {
-  type: "ImportNamespaceSpecifier";
-  local: BindingIdentifier$1;
-  parent?: Node$1;
-}
-declare type ImportOrExportKind = "value" | "type";
-declare type ImportPhase = "source" | "defer";
-declare interface ImportSpecifier extends Span$1 {
-  type: "ImportSpecifier";
-  imported: ModuleExportName;
-  local: BindingIdentifier$1;
-  importKind?: ImportOrExportKind;
-  parent?: Node$1;
-}
-declare interface JSDocNonNullableType$1 extends Span$1 {
-  type: "TSJSDocNonNullableType";
-  typeAnnotation: TSType$1;
-  postfix: boolean;
-  parent?: Node$1;
-}
-declare interface JSDocNullableType$1 extends Span$1 {
-  type: "TSJSDocNullableType";
-  typeAnnotation: TSType$1;
-  postfix: boolean;
-  parent?: Node$1;
-}
-declare interface JSDocUnknownType extends Span$1 {
-  type: "TSJSDocUnknownType";
-  parent?: Node$1;
-}
-declare interface JSXAttribute$1 extends Span$1 {
-  type: "JSXAttribute";
-  name: JSXAttributeName;
-  value: JSXAttributeValue | null;
-  parent?: Node$1;
-}
-declare type JSXAttributeItem = JSXAttribute$1 | JSXSpreadAttribute$1;
-declare type JSXAttributeName = JSXIdentifier$1 | JSXNamespacedName$1;
-declare type JSXAttributeValue = StringLiteral$1 | JSXExpressionContainer$1 | JSXElement$1 | JSXFragment$1;
-declare type JSXChild = JSXText$1 | JSXElement$1 | JSXFragment$1 | JSXExpressionContainer$1 | JSXSpreadChild$1;
-declare interface JSXClosingElement extends Span$1 {
-  type: "JSXClosingElement";
-  name: JSXElementName;
+interface ContinueStatement$1 extends Span$1 {
+  type: "ContinueStatement";
+  label: LabelIdentifier$1 | null;
   parent?: Node$1;
 }
-declare interface JSXClosingFragment extends Span$1 {
-  type: "JSXClosingFragment";
+interface BreakStatement$1 extends Span$1 {
+  type: "BreakStatement";
+  label: LabelIdentifier$1 | null;
   parent?: Node$1;
 }
-declare interface JSXElement$1 extends Span$1 {
-  type: "JSXElement";
-  openingElement: JSXOpeningElement$1;
-  children: Array<JSXChild>;
-  closingElement: JSXClosingElement | null;
+interface ReturnStatement$1 extends Span$1 {
+  type: "ReturnStatement";
+  argument: Expression$1 | null;
   parent?: Node$1;
 }
-declare type JSXElementName = JSXIdentifier$1 | JSXNamespacedName$1 | JSXMemberExpression$1;
-declare interface JSXEmptyExpression extends Span$1 {
-  type: "JSXEmptyExpression";
+interface WithStatement$1 extends Span$1 {
+  type: "WithStatement";
+  object: Expression$1;
+  body: Statement$1;
   parent?: Node$1;
 }
-declare type JSXExpression = JSXEmptyExpression | Expression$1;
-declare interface JSXExpressionContainer$1 extends Span$1 {
-  type: "JSXExpressionContainer";
-  expression: JSXExpression;
+interface SwitchStatement$1 extends Span$1 {
+  type: "SwitchStatement";
+  discriminant: Expression$1;
+  cases: Array<SwitchCase$1>;
   parent?: Node$1;
 }
-declare interface JSXFragment$1 extends Span$1 {
-  type: "JSXFragment";
-  openingFragment: JSXOpeningFragment;
-  children: Array<JSXChild>;
-  closingFragment: JSXClosingFragment;
+interface SwitchCase$1 extends Span$1 {
+  type: "SwitchCase";
+  test: Expression$1 | null;
+  consequent: Array<Statement$1>;
   parent?: Node$1;
 }
-declare interface JSXIdentifier$1 extends Span$1 {
-  type: "JSXIdentifier";
-  name: string;
+interface LabeledStatement$1 extends Span$1 {
+  type: "LabeledStatement";
+  label: LabelIdentifier$1;
+  body: Statement$1;
   parent?: Node$1;
 }
-declare interface JSXMemberExpression$1 extends Span$1 {
-  type: "JSXMemberExpression";
-  object: JSXMemberExpressionObject;
-  property: JSXIdentifier$1;
+interface ThrowStatement$1 extends Span$1 {
+  type: "ThrowStatement";
+  argument: Expression$1;
   parent?: Node$1;
 }
-declare type JSXMemberExpressionObject = JSXIdentifier$1 | JSXMemberExpression$1;
-declare interface JSXNamespacedName$1 extends Span$1 {
-  type: "JSXNamespacedName";
-  namespace: JSXIdentifier$1;
-  name: JSXIdentifier$1;
+interface TryStatement$1 extends Span$1 {
+  type: "TryStatement";
+  block: BlockStatement$1;
+  handler: CatchClause$1 | null;
+  finalizer: BlockStatement$1 | null;
   parent?: Node$1;
 }
-declare interface JSXOpeningElement$1 extends Span$1 {
-  type: "JSXOpeningElement";
-  name: JSXElementName;
-  typeArguments?: TSTypeParameterInstantiation$1 | null;
-  attributes: Array<JSXAttributeItem>;
-  selfClosing: boolean;
+interface CatchClause$1 extends Span$1 {
+  type: "CatchClause";
+  param: BindingPattern$1 | null;
+  body: BlockStatement$1;
   parent?: Node$1;
 }
-declare interface JSXOpeningFragment extends Span$1 {
-  type: "JSXOpeningFragment";
-  attributes?: [];
-  selfClosing?: false;
+interface DebuggerStatement extends Span$1 {
+  type: "DebuggerStatement";
   parent?: Node$1;
 }
-declare interface JSXSpreadAttribute$1 extends Span$1 {
-  type: "JSXSpreadAttribute";
-  argument: Expression$1;
+type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
+interface AssignmentPattern$1 extends Span$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: BindingPattern$1;
+  right: Expression$1;
+  optional?: false;
+  typeAnnotation?: null;
   parent?: Node$1;
 }
-declare interface JSXSpreadChild$1 extends Span$1 {
-  type: "JSXSpreadChild";
-  expression: Expression$1;
+interface ObjectPattern extends Span$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<BindingProperty$1 | BindingRestElement$1>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare interface JSXText$1 extends Span$1 {
-  type: "JSXText";
-  value: string;
-  raw: string | null;
+interface BindingProperty$1 extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey;
+  value: BindingPattern$1;
+  method: false;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
   parent?: Node$1;
 }
-declare interface LabeledStatement$1 extends Span$1 {
-  type: "LabeledStatement";
-  label: LabelIdentifier$1;
-  body: Statement$1;
+interface ArrayPattern$1 extends Span$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<BindingPattern$1 | BindingRestElement$1 | null>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare interface LabelIdentifier$1 extends Span$1 {
-  type: "Identifier";
+interface BindingRestElement$1 extends Span$1 {
+  type: "RestElement";
   decorators?: [];
-  name: string;
+  argument: BindingPattern$1;
   optional?: false;
-  typeAnnotation?: null;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value?: null;
   parent?: Node$1;
 }
-declare interface LogicalExpression$1 extends Span$1 {
-  type: "LogicalExpression";
-  left: Expression$1;
-  operator: LogicalOperator;
-  right: Expression$1;
+interface Function$1 extends Span$1 {
+  type: FunctionType;
+  id: BindingIdentifier$1 | null;
+  generator: boolean;
+  async: boolean;
+  declare?: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType?: TSTypeAnnotation$1 | null;
+  body: FunctionBody | null;
+  expression: false;
   parent?: Node$1;
 }
-declare type LogicalOperator = "||" | "&&" | "??";
-declare type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
-declare interface MetaProperty$1 extends Span$1 {
-  type: "MetaProperty";
-  meta: IdentifierName$1;
-  property: IdentifierName$1;
+type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
+type FunctionType = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
+interface FormalParameterRest extends Span$1 {
+  type: "RestElement";
+  argument: BindingPattern$1;
+  decorators?: Array<Decorator$1>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value?: null;
   parent?: Node$1;
 }
-declare interface MethodDefinition$1 extends Span$1 {
-  type: MethodDefinitionType;
+type FormalParameter = {
+  decorators?: Array<Decorator$1>;
+} & BindingPattern$1;
+interface TSParameterProperty extends Span$1 {
+  type: "TSParameterProperty";
+  accessibility: TSAccessibility | null;
   decorators: Array<Decorator$1>;
-  key: PropertyKey_2;
-  value: Function$1;
-  kind: MethodDefinitionKind;
-  computed: boolean;
+  override: boolean;
+  parameter: FormalParameter;
+  readonly: boolean;
   static: boolean;
-  override?: boolean;
-  optional?: boolean;
-  accessibility?: TSAccessibility | null;
   parent?: Node$1;
 }
-declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
-declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
-declare type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
-declare type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
-declare type ModuleKind = "script" | "module" | "commonjs";
-declare interface NewExpression$1 extends Span$1 {
-  type: "NewExpression";
-  callee: Expression$1;
-  typeArguments?: TSTypeParameterInstantiation$1 | null;
-  arguments: Array<Argument$1>;
-  parent?: Node$1;
-}
-declare type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
-declare type Node_2 = Simplify<Built<Node$1>> | Node$1;
-declare interface NullLiteral$1 extends Span$1 {
-  type: "Literal";
-  value: null;
-  raw: "null" | null;
+interface FunctionBody extends Span$1 {
+  type: "BlockStatement";
+  body: Array<Directive | Statement$1>;
   parent?: Node$1;
 }
-declare interface NumericLiteral$1 extends Span$1 {
-  type: "Literal";
-  value: number;
-  raw: string | null;
+interface ArrowFunctionExpression$1 extends Span$1 {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  async: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType?: TSTypeAnnotation$1 | null;
+  body: FunctionBody | Expression$1;
+  id: null;
+  generator: false;
   parent?: Node$1;
 }
-declare interface ObjectAssignmentTarget extends Span$1 {
-  type: "ObjectPattern";
-  decorators?: [];
-  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
-  optional?: false;
-  typeAnnotation?: null;
+interface YieldExpression$1 extends Span$1 {
+  type: "YieldExpression";
+  delegate: boolean;
+  argument: Expression$1 | null;
   parent?: Node$1;
 }
-declare interface ObjectExpression$1 extends Span$1 {
-  type: "ObjectExpression";
-  properties: Array<ObjectPropertyKind>;
+interface Class$1 extends Span$1 {
+  type: ClassType;
+  decorators: Array<Decorator$1>;
+  id: BindingIdentifier$1 | null;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  superClass: Expression$1 | null;
+  superTypeArguments?: TSTypeParameterInstantiation$1 | null;
+  implements?: Array<TSClassImplements>;
+  body: ClassBody$1;
+  abstract?: boolean;
+  declare?: boolean;
   parent?: Node$1;
 }
-declare interface ObjectPattern extends Span$1 {
-  type: "ObjectPattern";
-  decorators?: [];
-  properties: Array<BindingProperty$1 | BindingRestElement$1>;
-  optional?: false;
-  typeAnnotation?: TSTypeAnnotation$1 | null;
+type ClassType = "ClassDeclaration" | "ClassExpression";
+interface ClassBody$1 extends Span$1 {
+  type: "ClassBody";
+  body: Array<ClassElement>;
   parent?: Node$1;
 }
-declare interface ObjectProperty$1 extends Span$1 {
-  type: "Property";
-  kind: PropertyKind;
-  key: PropertyKey_2;
-  value: Expression$1;
-  method: boolean;
-  shorthand: boolean;
+type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
+interface MethodDefinition$1 extends Span$1 {
+  type: MethodDefinitionType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey;
+  value: Function$1;
+  kind: MethodDefinitionKind;
   computed: boolean;
-  optional?: false;
-  parent?: Node$1;
-}
-declare type ObjectPropertyKind = ObjectProperty$1 | SpreadElement$1;
-declare type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
-declare interface ParenthesizedExpression extends Span$1 {
-  type: "ParenthesizedExpression";
-  expression: Expression$1;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: TSAccessibility | null;
   parent?: Node$1;
 }
-declare interface PrivateFieldExpression extends Span$1 {
-  type: "MemberExpression";
-  object: Expression$1;
-  property: PrivateIdentifier$1;
-  optional: boolean;
-  computed: false;
+type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
+interface PropertyDefinition$1 extends Span$1 {
+  type: PropertyDefinitionType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value: Expression$1 | null;
+  computed: boolean;
+  static: boolean;
+  declare?: boolean;
+  override?: boolean;
+  optional?: boolean;
+  definite?: boolean;
+  readonly?: boolean;
+  accessibility?: TSAccessibility | null;
   parent?: Node$1;
 }
-declare interface PrivateIdentifier$1 extends Span$1 {
+type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
+type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
+interface PrivateIdentifier$1 extends Span$1 {
   type: "PrivateIdentifier";
   name: string;
   parent?: Node$1;
 }
-declare interface PrivateInExpression$1 extends Span$1 {
-  type: "BinaryExpression";
-  left: PrivateIdentifier$1;
-  operator: "in";
-  right: Expression$1;
+interface StaticBlock$1 extends Span$1 {
+  type: "StaticBlock";
+  body: Array<Statement$1>;
   parent?: Node$1;
 }
-declare interface Program$1 extends Span$1 {
-  type: "Program";
-  body: Array<Directive | Statement$1>;
-  sourceType: ModuleKind;
-  hashbang: Hashbang | null;
-  parent?: null;
-}
-declare type Program = Simplify<Built<Program$1>>;
-declare interface PropertyDefinition$1 extends Span$1 {
-  type: PropertyDefinitionType;
+type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
+type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty";
+interface AccessorProperty$1 extends Span$1 {
+  type: AccessorPropertyType;
   decorators: Array<Decorator$1>;
-  key: PropertyKey_2;
+  key: PropertyKey;
   typeAnnotation?: TSTypeAnnotation$1 | null;
   value: Expression$1 | null;
   computed: boolean;
   static: boolean;
-  declare?: boolean;
   override?: boolean;
-  optional?: boolean;
   definite?: boolean;
-  readonly?: boolean;
   accessibility?: TSAccessibility | null;
+  declare?: false;
+  optional?: false;
+  readonly?: false;
   parent?: Node$1;
 }
-declare type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
-declare type PropertyKey_2 = IdentifierName$1 | PrivateIdentifier$1 | Expression$1;
-declare type PropertyKind = "init" | "get" | "set";
-declare interface RegExpLiteral$1 extends Span$1 {
-  type: "Literal";
-  value: RegExp | null;
-  raw: string | null;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
+interface ImportExpression$1 extends Span$1 {
+  type: "ImportExpression";
+  source: Expression$1;
+  options: Expression$1 | null;
+  phase: ImportPhase | null;
   parent?: Node$1;
 }
-declare interface ReturnStatement$1 extends Span$1 {
-  type: "ReturnStatement";
-  argument: Expression$1 | null;
+interface ImportDeclaration$1 extends Span$1 {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportDeclarationSpecifier>;
+  source: StringLiteral$1;
+  phase: ImportPhase | null;
+  attributes: Array<ImportAttribute$1>;
+  importKind?: ImportOrExportKind;
   parent?: Node$1;
 }
-declare interface SequenceExpression$1 extends Span$1 {
-  type: "SequenceExpression";
-  expressions: Array<Expression$1>;
+type ImportPhase = "source" | "defer";
+type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+interface ImportSpecifier extends Span$1 {
+  type: "ImportSpecifier";
+  imported: ModuleExportName;
+  local: BindingIdentifier$1;
+  importKind?: ImportOrExportKind;
   parent?: Node$1;
 }
-declare type SimpleAssignmentTarget$1 = IdentifierReference$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1 | MemberExpression$1;
-declare type Simplify<T> = { [K in keyof T]: T[K]; } & {};
-declare interface Span$1 {
-  start: number;
-  end: number;
-  range?: [number, number];
+interface ImportDefaultSpecifier extends Span$1 {
+  type: "ImportDefaultSpecifier";
+  local: BindingIdentifier$1;
+  parent?: Node$1;
 }
-declare interface SpreadElement$1 extends Span$1 {
-  type: "SpreadElement";
-  argument: Expression$1;
+interface ImportNamespaceSpecifier extends Span$1 {
+  type: "ImportNamespaceSpecifier";
+  local: BindingIdentifier$1;
   parent?: Node$1;
 }
-declare type Statement$1 = BlockStatement$1 | BreakStatement$1 | ContinueStatement$1 | DebuggerStatement | DoWhileStatement$1 | EmptyStatement$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | IfStatement$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | WhileStatement$1 | WithStatement$1 | Declaration | ModuleDeclaration;
-declare type Statement = Simplify<Built<Statement$1>> | Statement$1;
-declare interface StaticBlock$1 extends Span$1 {
-  type: "StaticBlock";
-  body: Array<Statement$1>;
+interface ImportAttribute$1 extends Span$1 {
+  type: "ImportAttribute";
+  key: ImportAttributeKey;
+  value: StringLiteral$1;
   parent?: Node$1;
 }
-declare interface StaticMemberExpression$1 extends Span$1 {
-  type: "MemberExpression";
-  object: Expression$1;
-  property: IdentifierName$1;
-  optional: boolean;
-  computed: false;
+type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
+interface ExportNamedDeclaration$1 extends Span$1 {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source: StringLiteral$1 | null;
+  exportKind?: ImportOrExportKind;
+  attributes: Array<ImportAttribute$1>;
+  parent?: Node$1;
+}
+interface ExportDefaultDeclaration$1 extends Span$1 {
+  type: "ExportDefaultDeclaration";
+  declaration: ExportDefaultDeclarationKind;
+  exportKind?: "value";
+  parent?: Node$1;
+}
+interface ExportAllDeclaration$1 extends Span$1 {
+  type: "ExportAllDeclaration";
+  exported: ModuleExportName | null;
+  source: StringLiteral$1;
+  attributes: Array<ImportAttribute$1>;
+  exportKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+interface ExportSpecifier extends Span$1 {
+  type: "ExportSpecifier";
+  local: ModuleExportName;
+  exported: ModuleExportName;
+  exportKind?: ImportOrExportKind;
   parent?: Node$1;
 }
-declare interface StringLiteral$1 extends Span$1 {
+type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
+type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
+interface V8IntrinsicExpression extends Span$1 {
+  type: "V8IntrinsicExpression";
+  name: IdentifierName$1;
+  arguments: Array<Argument$1>;
+  parent?: Node$1;
+}
+interface BooleanLiteral$1 extends Span$1 {
   type: "Literal";
-  value: string;
+  value: boolean;
   raw: string | null;
   parent?: Node$1;
 }
-declare interface Super$1 extends Span$1 {
-  type: "Super";
+interface NullLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: null;
+  raw: "null" | null;
   parent?: Node$1;
 }
-declare interface SwitchCase$1 extends Span$1 {
-  type: "SwitchCase";
-  test: Expression$1 | null;
-  consequent: Array<Statement$1>;
+interface NumericLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: number;
+  raw: string | null;
   parent?: Node$1;
 }
-declare interface SwitchStatement$1 extends Span$1 {
-  type: "SwitchStatement";
-  discriminant: Expression$1;
-  cases: Array<SwitchCase$1>;
+interface StringLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: string;
+  raw: string | null;
   parent?: Node$1;
 }
-declare interface TaggedTemplateExpression$1 extends Span$1 {
-  type: "TaggedTemplateExpression";
-  tag: Expression$1;
-  typeArguments?: TSTypeParameterInstantiation$1 | null;
-  quasi: TemplateLiteral$1;
+interface BigIntLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: bigint;
+  raw: string | null;
+  bigint: string;
   parent?: Node$1;
 }
-declare interface TemplateElement$1 extends Span$1 {
-  type: "TemplateElement";
-  value: TemplateElementValue;
-  tail: boolean;
+interface RegExpLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: RegExp | null;
+  raw: string | null;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
   parent?: Node$1;
 }
-declare interface TemplateElementValue {
-  raw: string;
-  cooked: string | null;
-}
-declare interface TemplateLiteral$1 extends Span$1 {
-  type: "TemplateLiteral";
-  quasis: Array<TemplateElement$1>;
-  expressions: Array<Expression$1>;
+interface JSXElement$1 extends Span$1 {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement$1;
+  children: Array<JSXChild>;
+  closingElement: JSXClosingElement | null;
   parent?: Node$1;
 }
-declare interface ThisExpression$1 extends Span$1 {
-  type: "ThisExpression";
+interface JSXOpeningElement$1 extends Span$1 {
+  type: "JSXOpeningElement";
+  name: JSXElementName;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  attributes: Array<JSXAttributeItem>;
+  selfClosing: boolean;
   parent?: Node$1;
 }
-declare interface ThrowStatement$1 extends Span$1 {
-  type: "ThrowStatement";
-  argument: Expression$1;
+interface JSXClosingElement extends Span$1 {
+  type: "JSXClosingElement";
+  name: JSXElementName;
   parent?: Node$1;
 }
-declare interface TryStatement$1 extends Span$1 {
-  type: "TryStatement";
-  block: BlockStatement$1;
-  handler: CatchClause$1 | null;
-  finalizer: BlockStatement$1 | null;
+interface JSXFragment$1 extends Span$1 {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  children: Array<JSXChild>;
+  closingFragment: JSXClosingFragment;
   parent?: Node$1;
 }
-declare type TSAccessibility = "private" | "protected" | "public";
-declare interface TSAnyKeyword extends Span$1 {
-  type: "TSAnyKeyword";
+interface JSXOpeningFragment extends Span$1 {
+  type: "JSXOpeningFragment";
+  attributes?: [];
+  selfClosing?: false;
   parent?: Node$1;
 }
-declare interface TSArrayType$1 extends Span$1 {
-  type: "TSArrayType";
-  elementType: TSType$1;
+interface JSXClosingFragment extends Span$1 {
+  type: "JSXClosingFragment";
   parent?: Node$1;
 }
-declare interface TSAsExpression$1 extends Span$1 {
-  type: "TSAsExpression";
-  expression: Expression$1;
-  typeAnnotation: TSType$1;
+type JSXElementName = JSXIdentifier$1 | JSXNamespacedName$1 | JSXMemberExpression$1;
+interface JSXNamespacedName$1 extends Span$1 {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier$1;
+  name: JSXIdentifier$1;
   parent?: Node$1;
 }
-declare interface TSBigIntKeyword extends Span$1 {
-  type: "TSBigIntKeyword";
+interface JSXMemberExpression$1 extends Span$1 {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpressionObject;
+  property: JSXIdentifier$1;
   parent?: Node$1;
 }
-declare interface TSBooleanKeyword extends Span$1 {
-  type: "TSBooleanKeyword";
+type JSXMemberExpressionObject = JSXIdentifier$1 | JSXMemberExpression$1;
+interface JSXExpressionContainer$1 extends Span$1 {
+  type: "JSXExpressionContainer";
+  expression: JSXExpression;
   parent?: Node$1;
 }
-declare interface TSCallSignatureDeclaration$1 extends Span$1 {
-  type: "TSCallSignatureDeclaration";
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType: TSTypeAnnotation$1 | null;
+type JSXExpression = JSXEmptyExpression | Expression$1;
+interface JSXEmptyExpression extends Span$1 {
+  type: "JSXEmptyExpression";
   parent?: Node$1;
 }
-declare interface TSClassImplements extends Span$1 {
-  type: "TSClassImplements";
-  expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
-  typeArguments: TSTypeParameterInstantiation$1 | null;
+type JSXAttributeItem = JSXAttribute$1 | JSXSpreadAttribute$1;
+interface JSXAttribute$1 extends Span$1 {
+  type: "JSXAttribute";
+  name: JSXAttributeName;
+  value: JSXAttributeValue | null;
   parent?: Node$1;
 }
-declare interface TSConditionalType$1 extends Span$1 {
-  type: "TSConditionalType";
-  checkType: TSType$1;
-  extendsType: TSType$1;
-  trueType: TSType$1;
-  falseType: TSType$1;
+interface JSXSpreadAttribute$1 extends Span$1 {
+  type: "JSXSpreadAttribute";
+  argument: Expression$1;
   parent?: Node$1;
 }
-declare interface TSConstructorType$1 extends Span$1 {
-  type: "TSConstructorType";
-  abstract: boolean;
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType: TSTypeAnnotation$1;
+type JSXAttributeName = JSXIdentifier$1 | JSXNamespacedName$1;
+type JSXAttributeValue = StringLiteral$1 | JSXExpressionContainer$1 | JSXElement$1 | JSXFragment$1;
+interface JSXIdentifier$1 extends Span$1 {
+  type: "JSXIdentifier";
+  name: string;
   parent?: Node$1;
 }
-declare interface TSConstructSignatureDeclaration$1 extends Span$1 {
-  type: "TSConstructSignatureDeclaration";
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType: TSTypeAnnotation$1 | null;
+type JSXChild = JSXText$1 | JSXElement$1 | JSXFragment$1 | JSXExpressionContainer$1 | JSXSpreadChild$1;
+interface JSXSpreadChild$1 extends Span$1 {
+  type: "JSXSpreadChild";
+  expression: Expression$1;
   parent?: Node$1;
 }
-declare interface TSEnumBody extends Span$1 {
-  type: "TSEnumBody";
-  members: Array<TSEnumMember>;
+interface JSXText$1 extends Span$1 {
+  type: "JSXText";
+  value: string;
+  raw: string | null;
+  parent?: Node$1;
+}
+interface TSThisParameter extends Span$1 {
+  type: "Identifier";
+  decorators: [];
+  name: "this";
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare interface TSEnumDeclaration$1 extends Span$1 {
+interface TSEnumDeclaration$1 extends Span$1 {
   type: "TSEnumDeclaration";
   id: BindingIdentifier$1;
   body: TSEnumBody;
@@ -890,433 +856,473 @@ declare interface TSEnumDeclaration$1 extends Span$1 {
   declare: boolean;
   parent?: Node$1;
 }
-declare interface TSEnumMember extends Span$1 {
+interface TSEnumBody extends Span$1 {
+  type: "TSEnumBody";
+  members: Array<TSEnumMember>;
+  parent?: Node$1;
+}
+interface TSEnumMember extends Span$1 {
   type: "TSEnumMember";
   id: TSEnumMemberName;
   initializer: Expression$1 | null;
   computed: boolean;
   parent?: Node$1;
 }
-declare type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
-declare interface TSExportAssignment$1 extends Span$1 {
-  type: "TSExportAssignment";
-  expression: Expression$1;
+type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
+interface TSTypeAnnotation$1 extends Span$1 {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType$1;
   parent?: Node$1;
 }
-declare interface TSExternalModuleReference extends Span$1 {
-  type: "TSExternalModuleReference";
-  expression: StringLiteral$1;
+interface TSLiteralType$1 extends Span$1 {
+  type: "TSLiteralType";
+  literal: TSLiteral;
   parent?: Node$1;
 }
-declare interface TSFunctionType$1 extends Span$1 {
-  type: "TSFunctionType";
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType: TSTypeAnnotation$1;
+type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
+type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
+interface TSConditionalType$1 extends Span$1 {
+  type: "TSConditionalType";
+  checkType: TSType$1;
+  extendsType: TSType$1;
+  trueType: TSType$1;
+  falseType: TSType$1;
   parent?: Node$1;
 }
-declare interface TSGlobalDeclaration extends Span$1 {
-  type: "TSModuleDeclaration";
-  id: IdentifierName$1;
-  body: TSModuleBlock$1;
-  kind: "global";
-  declare: boolean;
-  global: true;
+interface TSUnionType$1 extends Span$1 {
+  type: "TSUnionType";
+  types: Array<TSType$1>;
   parent?: Node$1;
 }
-declare interface TSImportEqualsDeclaration$1 extends Span$1 {
-  type: "TSImportEqualsDeclaration";
-  id: BindingIdentifier$1;
-  moduleReference: TSModuleReference;
-  importKind: ImportOrExportKind;
+interface TSIntersectionType$1 extends Span$1 {
+  type: "TSIntersectionType";
+  types: Array<TSType$1>;
   parent?: Node$1;
 }
-declare interface TSImportType$1 extends Span$1 {
-  type: "TSImportType";
-  source: StringLiteral$1;
-  options: ObjectExpression$1 | null;
-  qualifier: TSImportTypeQualifier | null;
-  typeArguments: TSTypeParameterInstantiation$1 | null;
+interface TSParenthesizedType$1 extends Span$1 {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType$1;
   parent?: Node$1;
 }
-declare interface TSImportTypeQualifiedName extends Span$1 {
-  type: "TSQualifiedName";
-  left: TSImportTypeQualifier;
-  right: IdentifierName$1;
+interface TSTypeOperator$1 extends Span$1 {
+  type: "TSTypeOperator";
+  operator: TSTypeOperatorOperator;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
+interface TSArrayType$1 extends Span$1 {
+  type: "TSArrayType";
+  elementType: TSType$1;
   parent?: Node$1;
 }
-declare type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
-declare interface TSIndexedAccessType$1 extends Span$1 {
+interface TSIndexedAccessType$1 extends Span$1 {
   type: "TSIndexedAccessType";
   objectType: TSType$1;
   indexType: TSType$1;
   parent?: Node$1;
 }
-declare interface TSIndexSignature$1 extends Span$1 {
-  type: "TSIndexSignature";
-  parameters: Array<TSIndexSignatureName>;
-  typeAnnotation: TSTypeAnnotation$1;
-  readonly: boolean;
-  static: boolean;
-  accessibility: null;
+interface TSTupleType$1 extends Span$1 {
+  type: "TSTupleType";
+  elementTypes: Array<TSTupleElement>;
   parent?: Node$1;
 }
-declare interface TSIndexSignatureName extends Span$1 {
-  type: "Identifier";
-  decorators: [];
-  name: string;
-  optional: false;
-  typeAnnotation: TSTypeAnnotation$1;
+interface TSNamedTupleMember$1 extends Span$1 {
+  type: "TSNamedTupleMember";
+  label: IdentifierName$1;
+  elementType: TSTupleElement;
+  optional: boolean;
   parent?: Node$1;
 }
-declare interface TSInferType$1 extends Span$1 {
-  type: "TSInferType";
-  typeParameter: TSTypeParameter;
+interface TSOptionalType$1 extends Span$1 {
+  type: "TSOptionalType";
+  typeAnnotation: TSType$1;
   parent?: Node$1;
 }
-declare interface TSInstantiationExpression$1 extends Span$1 {
-  type: "TSInstantiationExpression";
-  expression: Expression$1;
-  typeArguments: TSTypeParameterInstantiation$1;
+interface TSRestType$1 extends Span$1 {
+  type: "TSRestType";
+  typeAnnotation: TSType$1;
   parent?: Node$1;
 }
-declare interface TSInterfaceBody$1 extends Span$1 {
-  type: "TSInterfaceBody";
-  body: Array<TSSignature>;
+type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
+interface TSAnyKeyword extends Span$1 {
+  type: "TSAnyKeyword";
   parent?: Node$1;
 }
-declare interface TSInterfaceDeclaration$1 extends Span$1 {
-  type: "TSInterfaceDeclaration";
-  id: BindingIdentifier$1;
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  extends: Array<TSInterfaceHeritage>;
-  body: TSInterfaceBody$1;
-  declare: boolean;
+interface TSStringKeyword extends Span$1 {
+  type: "TSStringKeyword";
   parent?: Node$1;
 }
-declare interface TSInterfaceHeritage extends Span$1 {
-  type: "TSInterfaceHeritage";
-  expression: Expression$1;
-  typeArguments: TSTypeParameterInstantiation$1 | null;
+interface TSBooleanKeyword extends Span$1 {
+  type: "TSBooleanKeyword";
   parent?: Node$1;
 }
-declare interface TSIntersectionType$1 extends Span$1 {
-  type: "TSIntersectionType";
-  types: Array<TSType$1>;
+interface TSNumberKeyword extends Span$1 {
+  type: "TSNumberKeyword";
+  parent?: Node$1;
+}
+interface TSNeverKeyword extends Span$1 {
+  type: "TSNeverKeyword";
   parent?: Node$1;
 }
-declare interface TSIntrinsicKeyword extends Span$1 {
+interface TSIntrinsicKeyword extends Span$1 {
   type: "TSIntrinsicKeyword";
   parent?: Node$1;
 }
-declare type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
-declare interface TSLiteralType$1 extends Span$1 {
-  type: "TSLiteralType";
-  literal: TSLiteral;
+interface TSUnknownKeyword extends Span$1 {
+  type: "TSUnknownKeyword";
   parent?: Node$1;
 }
-declare interface TSMappedType$1 extends Span$1 {
-  type: "TSMappedType";
-  key: BindingIdentifier$1;
-  constraint: TSType$1;
-  nameType: TSType$1 | null;
-  typeAnnotation: TSType$1 | null;
-  optional: TSMappedTypeModifierOperator | false;
-  readonly: TSMappedTypeModifierOperator | null;
+interface TSNullKeyword extends Span$1 {
+  type: "TSNullKeyword";
   parent?: Node$1;
 }
-declare type TSMappedTypeModifierOperator = true | "+" | "-";
-declare interface TSMethodSignature$1 extends Span$1 {
-  type: "TSMethodSignature";
-  key: PropertyKey_2;
-  computed: boolean;
-  optional: boolean;
-  kind: TSMethodSignatureKind;
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  params: ParamPattern$1[];
-  returnType: TSTypeAnnotation$1 | null;
-  accessibility: null;
-  readonly: false;
-  static: false;
+interface TSUndefinedKeyword extends Span$1 {
+  type: "TSUndefinedKeyword";
   parent?: Node$1;
 }
-declare type TSMethodSignatureKind = "method" | "get" | "set";
-declare interface TSModuleBlock$1 extends Span$1 {
-  type: "TSModuleBlock";
-  body: Array<Directive | Statement$1>;
+interface TSVoidKeyword extends Span$1 {
+  type: "TSVoidKeyword";
   parent?: Node$1;
 }
-declare interface TSModuleDeclaration$1 extends Span$1 {
-  type: "TSModuleDeclaration";
-  id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
-  body: TSModuleBlock$1 | null;
-  kind: TSModuleDeclarationKind;
-  declare: boolean;
-  global: false;
+interface TSSymbolKeyword extends Span$1 {
+  type: "TSSymbolKeyword";
   parent?: Node$1;
 }
-declare type TSModuleDeclarationKind = "module" | "namespace";
-declare type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
-declare interface TSNamedTupleMember$1 extends Span$1 {
-  type: "TSNamedTupleMember";
-  label: IdentifierName$1;
-  elementType: TSTupleElement;
-  optional: boolean;
+interface TSThisType extends Span$1 {
+  type: "TSThisType";
   parent?: Node$1;
 }
-declare interface TSNamespaceExportDeclaration$1 extends Span$1 {
-  type: "TSNamespaceExportDeclaration";
-  id: IdentifierName$1;
+interface TSObjectKeyword extends Span$1 {
+  type: "TSObjectKeyword";
   parent?: Node$1;
 }
-declare interface TSNeverKeyword extends Span$1 {
-  type: "TSNeverKeyword";
+interface TSBigIntKeyword extends Span$1 {
+  type: "TSBigIntKeyword";
   parent?: Node$1;
 }
-declare interface TSNonNullExpression$1 extends Span$1 {
-  type: "TSNonNullExpression";
-  expression: Expression$1;
+interface TSTypeReference$1 extends Span$1 {
+  type: "TSTypeReference";
+  typeName: TSTypeName;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
   parent?: Node$1;
 }
-declare interface TSNullKeyword extends Span$1 {
-  type: "TSNullKeyword";
+type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
+interface TSQualifiedName$1 extends Span$1 {
+  type: "TSQualifiedName";
+  left: TSTypeName;
+  right: IdentifierName$1;
   parent?: Node$1;
 }
-declare interface TSNumberKeyword extends Span$1 {
-  type: "TSNumberKeyword";
+interface TSTypeParameterInstantiation$1 extends Span$1 {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType$1>;
   parent?: Node$1;
 }
-declare interface TSObjectKeyword extends Span$1 {
-  type: "TSObjectKeyword";
+interface TSTypeParameter extends Span$1 {
+  type: "TSTypeParameter";
+  name: BindingIdentifier$1;
+  constraint: TSType$1 | null;
+  default: TSType$1 | null;
+  in: boolean;
+  out: boolean;
+  const: boolean;
   parent?: Node$1;
 }
-declare interface TSOptionalType$1 extends Span$1 {
-  type: "TSOptionalType";
+interface TSTypeParameterDeclaration$1 extends Span$1 {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter>;
+  parent?: Node$1;
+}
+interface TSTypeAliasDeclaration$1 extends Span$1 {
+  type: "TSTypeAliasDeclaration";
+  id: BindingIdentifier$1;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
   typeAnnotation: TSType$1;
+  declare: boolean;
   parent?: Node$1;
 }
-declare interface TSParameterProperty extends Span$1 {
-  type: "TSParameterProperty";
-  accessibility: TSAccessibility | null;
-  decorators: Array<Decorator$1>;
-  override: boolean;
-  parameter: FormalParameter;
-  readonly: boolean;
-  static: boolean;
+type TSAccessibility = "private" | "protected" | "public";
+interface TSClassImplements extends Span$1 {
+  type: "TSClassImplements";
+  expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
   parent?: Node$1;
 }
-declare interface TSParenthesizedType$1 extends Span$1 {
-  type: "TSParenthesizedType";
-  typeAnnotation: TSType$1;
+interface TSInterfaceDeclaration$1 extends Span$1 {
+  type: "TSInterfaceDeclaration";
+  id: BindingIdentifier$1;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  extends: Array<TSInterfaceHeritage>;
+  body: TSInterfaceBody$1;
+  declare: boolean;
+  parent?: Node$1;
+}
+interface TSInterfaceBody$1 extends Span$1 {
+  type: "TSInterfaceBody";
+  body: Array<TSSignature>;
   parent?: Node$1;
 }
-declare interface TSPropertySignature$1 extends Span$1 {
+interface TSPropertySignature$1 extends Span$1 {
   type: "TSPropertySignature";
   computed: boolean;
   optional: boolean;
   readonly: boolean;
-  key: PropertyKey_2;
+  key: PropertyKey;
   typeAnnotation: TSTypeAnnotation$1 | null;
   accessibility: null;
   static: false;
   parent?: Node$1;
 }
-declare interface TSQualifiedName$1 extends Span$1 {
-  type: "TSQualifiedName";
-  left: TSTypeName;
-  right: IdentifierName$1;
-  parent?: Node$1;
-}
-declare interface TSRestType$1 extends Span$1 {
-  type: "TSRestType";
-  typeAnnotation: TSType$1;
-  parent?: Node$1;
-}
-declare interface TSSatisfiesExpression$1 extends Span$1 {
-  type: "TSSatisfiesExpression";
-  expression: Expression$1;
-  typeAnnotation: TSType$1;
+type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
+interface TSIndexSignature$1 extends Span$1 {
+  type: "TSIndexSignature";
+  parameters: Array<TSIndexSignatureName>;
+  typeAnnotation: TSTypeAnnotation$1;
+  readonly: boolean;
+  static: boolean;
+  accessibility: null;
   parent?: Node$1;
 }
-declare type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
-declare interface TSStringKeyword extends Span$1 {
-  type: "TSStringKeyword";
+interface TSCallSignatureDeclaration$1 extends Span$1 {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare interface TSSymbolKeyword extends Span$1 {
-  type: "TSSymbolKeyword";
+type TSMethodSignatureKind = "method" | "get" | "set";
+interface TSMethodSignature$1 extends Span$1 {
+  type: "TSMethodSignature";
+  key: PropertyKey;
+  computed: boolean;
+  optional: boolean;
+  kind: TSMethodSignatureKind;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  accessibility: null;
+  readonly: false;
+  static: false;
   parent?: Node$1;
 }
-declare interface TSTemplateLiteralType$1 extends Span$1 {
-  type: "TSTemplateLiteralType";
-  quasis: Array<TemplateElement$1>;
-  types: Array<TSType$1>;
+interface TSConstructSignatureDeclaration$1 extends Span$1 {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare interface TSThisParameter extends Span$1 {
+interface TSIndexSignatureName extends Span$1 {
   type: "Identifier";
   decorators: [];
-  name: "this";
+  name: string;
   optional: false;
-  typeAnnotation: TSTypeAnnotation$1 | null;
+  typeAnnotation: TSTypeAnnotation$1;
   parent?: Node$1;
 }
-declare interface TSThisType extends Span$1 {
-  type: "TSThisType";
+interface TSInterfaceHeritage extends Span$1 {
+  type: "TSInterfaceHeritage";
+  expression: Expression$1;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
   parent?: Node$1;
 }
-declare type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
-declare interface TSTupleType$1 extends Span$1 {
-  type: "TSTupleType";
-  elementTypes: Array<TSTupleElement>;
+interface TSTypePredicate$1 extends Span$1 {
+  type: "TSTypePredicate";
+  parameterName: TSTypePredicateName;
+  asserts: boolean;
+  typeAnnotation: TSTypeAnnotation$1 | null;
   parent?: Node$1;
 }
-declare type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
-declare interface TSTypeAliasDeclaration$1 extends Span$1 {
-  type: "TSTypeAliasDeclaration";
-  id: BindingIdentifier$1;
-  typeParameters: TSTypeParameterDeclaration$1 | null;
-  typeAnnotation: TSType$1;
+type TSTypePredicateName = IdentifierName$1 | TSThisType;
+type TSModuleDeclarationKind = "module" | "namespace";
+interface TSModuleDeclaration$1 extends Span$1 {
+  type: "TSModuleDeclaration";
+  id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
+  body: TSModuleBlock$1 | null;
+  kind: TSModuleDeclarationKind;
   declare: boolean;
+  global: false;
   parent?: Node$1;
 }
-declare interface TSTypeAnnotation$1 extends Span$1 {
-  type: "TSTypeAnnotation";
-  typeAnnotation: TSType$1;
+interface TSGlobalDeclaration extends Span$1 {
+  type: "TSModuleDeclaration";
+  id: IdentifierName$1;
+  body: TSModuleBlock$1;
+  kind: "global";
+  declare: boolean;
+  global: true;
   parent?: Node$1;
 }
-declare interface TSTypeAssertion$1 extends Span$1 {
-  type: "TSTypeAssertion";
-  typeAnnotation: TSType$1;
-  expression: Expression$1;
+interface TSModuleBlock$1 extends Span$1 {
+  type: "TSModuleBlock";
+  body: Array<Directive | Statement$1>;
   parent?: Node$1;
 }
-declare interface TSTypeLiteral extends Span$1 {
+interface TSTypeLiteral extends Span$1 {
   type: "TSTypeLiteral";
   members: Array<TSSignature>;
   parent?: Node$1;
 }
-declare type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
-declare interface TSTypeOperator$1 extends Span$1 {
-  type: "TSTypeOperator";
-  operator: TSTypeOperatorOperator;
-  typeAnnotation: TSType$1;
+interface TSInferType$1 extends Span$1 {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
   parent?: Node$1;
 }
-declare type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
-declare interface TSTypeParameter extends Span$1 {
-  type: "TSTypeParameter";
-  name: BindingIdentifier$1;
-  constraint: TSType$1 | null;
-  default: TSType$1 | null;
-  in: boolean;
-  out: boolean;
-  const: boolean;
+interface TSTypeQuery$1 extends Span$1 {
+  type: "TSTypeQuery";
+  exprName: TSTypeQueryExprName;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
   parent?: Node$1;
 }
-declare interface TSTypeParameterDeclaration$1 extends Span$1 {
-  type: "TSTypeParameterDeclaration";
-  params: Array<TSTypeParameter>;
+type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
+interface TSImportType$1 extends Span$1 {
+  type: "TSImportType";
+  source: StringLiteral$1;
+  options: ObjectExpression$1 | null;
+  qualifier: TSImportTypeQualifier | null;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
   parent?: Node$1;
 }
-declare interface TSTypeParameterInstantiation$1 extends Span$1 {
-  type: "TSTypeParameterInstantiation";
-  params: Array<TSType$1>;
+type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
+interface TSImportTypeQualifiedName extends Span$1 {
+  type: "TSQualifiedName";
+  left: TSImportTypeQualifier;
+  right: IdentifierName$1;
   parent?: Node$1;
 }
-declare interface TSTypePredicate$1 extends Span$1 {
-  type: "TSTypePredicate";
-  parameterName: TSTypePredicateName;
-  asserts: boolean;
-  typeAnnotation: TSTypeAnnotation$1 | null;
+interface TSFunctionType$1 extends Span$1 {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1;
   parent?: Node$1;
 }
-declare type TSTypePredicateName = IdentifierName$1 | TSThisType;
-declare interface TSTypeQuery$1 extends Span$1 {
-  type: "TSTypeQuery";
-  exprName: TSTypeQueryExprName;
-  typeArguments: TSTypeParameterInstantiation$1 | null;
+interface TSConstructorType$1 extends Span$1 {
+  type: "TSConstructorType";
+  abstract: boolean;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1;
   parent?: Node$1;
 }
-declare type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
-declare interface TSTypeReference$1 extends Span$1 {
-  type: "TSTypeReference";
-  typeName: TSTypeName;
-  typeArguments: TSTypeParameterInstantiation$1 | null;
+interface TSMappedType$1 extends Span$1 {
+  type: "TSMappedType";
+  key: BindingIdentifier$1;
+  constraint: TSType$1;
+  nameType: TSType$1 | null;
+  typeAnnotation: TSType$1 | null;
+  optional: TSMappedTypeModifierOperator | false;
+  readonly: TSMappedTypeModifierOperator | null;
   parent?: Node$1;
 }
-declare interface TSUndefinedKeyword extends Span$1 {
-  type: "TSUndefinedKeyword";
+type TSMappedTypeModifierOperator = true | "+" | "-";
+interface TSTemplateLiteralType$1 extends Span$1 {
+  type: "TSTemplateLiteralType";
+  quasis: Array<TemplateElement$1>;
+  types: Array<TSType$1>;
   parent?: Node$1;
 }
-declare interface TSUnionType$1 extends Span$1 {
-  type: "TSUnionType";
-  types: Array<TSType$1>;
+interface TSAsExpression$1 extends Span$1 {
+  type: "TSAsExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType$1;
   parent?: Node$1;
 }
-declare interface TSUnknownKeyword extends Span$1 {
-  type: "TSUnknownKeyword";
+interface TSSatisfiesExpression$1 extends Span$1 {
+  type: "TSSatisfiesExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType$1;
   parent?: Node$1;
 }
-declare interface TSVoidKeyword extends Span$1 {
-  type: "TSVoidKeyword";
+interface TSTypeAssertion$1 extends Span$1 {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType$1;
+  expression: Expression$1;
   parent?: Node$1;
 }
-declare interface UnaryExpression$1 extends Span$1 {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  argument: Expression$1;
-  prefix: true;
+interface TSImportEqualsDeclaration$1 extends Span$1 {
+  type: "TSImportEqualsDeclaration";
+  id: BindingIdentifier$1;
+  moduleReference: TSModuleReference;
+  importKind: ImportOrExportKind;
   parent?: Node$1;
 }
-declare type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
-declare interface UpdateExpression$1 extends Span$1 {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  prefix: boolean;
-  argument: SimpleAssignmentTarget$1;
+type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
+interface TSExternalModuleReference extends Span$1 {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral$1;
   parent?: Node$1;
 }
-declare type UpdateOperator = "++" | "--";
-declare interface V8IntrinsicExpression extends Span$1 {
-  type: "V8IntrinsicExpression";
-  name: IdentifierName$1;
-  arguments: Array<Argument$1>;
+interface TSNonNullExpression$1 extends Span$1 {
+  type: "TSNonNullExpression";
+  expression: Expression$1;
   parent?: Node$1;
 }
-declare interface VariableDeclaration$1 extends Span$1 {
-  type: "VariableDeclaration";
-  kind: VariableDeclarationKind;
-  declarations: Array<VariableDeclarator$1>;
-  declare?: boolean;
+interface Decorator$1 extends Span$1 {
+  type: "Decorator";
+  expression: Expression$1;
   parent?: Node$1;
 }
-declare type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
-declare interface VariableDeclarator$1 extends Span$1 {
-  type: "VariableDeclarator";
-  id: BindingPattern$1;
-  init: Expression$1 | null;
-  definite?: boolean;
+interface TSExportAssignment$1 extends Span$1 {
+  type: "TSExportAssignment";
+  expression: Expression$1;
   parent?: Node$1;
 }
-declare interface WhileStatement$1 extends Span$1 {
-  type: "WhileStatement";
-  test: Expression$1;
-  body: Statement$1;
+interface TSNamespaceExportDeclaration$1 extends Span$1 {
+  type: "TSNamespaceExportDeclaration";
+  id: IdentifierName$1;
   parent?: Node$1;
 }
-declare interface WithStatement$1 extends Span$1 {
-  type: "WithStatement";
-  object: Expression$1;
-  body: Statement$1;
+interface TSInstantiationExpression$1 extends Span$1 {
+  type: "TSInstantiationExpression";
+  expression: Expression$1;
+  typeArguments: TSTypeParameterInstantiation$1;
   parent?: Node$1;
 }
-declare interface YieldExpression$1 extends Span$1 {
-  type: "YieldExpression";
-  delegate: boolean;
-  argument: Expression$1 | null;
+type ImportOrExportKind = "value" | "type";
+interface JSDocNullableType$1 extends Span$1 {
+  type: "TSJSDocNullableType";
+  typeAnnotation: TSType$1;
+  postfix: boolean;
+  parent?: Node$1;
+}
+interface JSDocNonNullableType$1 extends Span$1 {
+  type: "TSJSDocNonNullableType";
+  typeAnnotation: TSType$1;
+  postfix: boolean;
+  parent?: Node$1;
+}
+interface JSDocUnknownType extends Span$1 {
+  type: "TSJSDocUnknownType";
   parent?: Node$1;
 }
+type ModuleKind = "script" | "module" | "commonjs";
+interface Span$1 {
+  start: number;
+  end: number;
+  range?: [number, number];
+}
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
+type UpdateOperator = "++" | "--";
+type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
+//#endregion
+//#region src/node.d.ts
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+type Built<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built<T[number]>> : T) : T extends Span$1 ? { [K in keyof T as K extends keyof Span$1 ? never : K]: Child<T[K]>; } & Partial<Pick<T, keyof Span$1>> : T;
+type Child<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child<T[number]>> : T) : T extends Span$1 ? Built<T> | T : T;
+type Program = Simplify<Built<Program$1>>;
+type Statement = Simplify<Built<Statement$1>> | Statement$1;
+type Node = Simplify<Built<Node$1>> | Node$1;
+//#endregion
+//#region src/ignorer.d.ts
+interface Ignorer {
+  readonly name: string;
+  shouldIgnore(node: Node, ancestors: readonly Node[]): string | undefined;
+}
 //#endregion
 //#region ../stryker-js-plugin-interface/dist/index.d.mts
 //#region src/Checker.schema.d.ts
@@ -1355,6 +1361,15 @@ declare const CheckerMutantWire: S.Struct<{
   }>, never, never>;
 }>;
 type CheckerMutantWire = typeof CheckerMutantWire.Type;
+/**
+ * The digest of the TypeScript program a checker loaded: SHA-256 over the sorted
+ * hashes of every source file in the program (lib and node_modules declarations
+ * included), every tsconfig in its chain, the TypeScript version, the checker
+ * plugin version, and the checker's options. A `CompileError` verdict is reusable
+ * only when two runs' digests are byte-equal, so a missing digest is never a match.
+ */
+declare const ProgramDigest: S.brand<S.String, "ProgramDigest">;
+type ProgramDigest = typeof ProgramDigest.Type;
 declare const CheckResultSchema: S.toTaggedUnion<"status", readonly [S.Struct<{
   readonly status: S.Literal<"passed">;
 }>, S.Struct<{
@@ -1364,13 +1379,25 @@ declare const CheckResultSchema: S.toTaggedUnion<"status", readonly [S.Struct<{
   readonly status: S.Literal<"ignored">;
   readonly reason: S.String;
 }>]>;
+declare const CheckAnswerSchema: S.toTaggedUnion<"status", readonly [S.Struct<{
+  readonly status: S.Literal<"passed">;
+}>, S.Struct<{
+  readonly status: S.Literal<"compileError">;
+  readonly reason: S.String;
+}>, S.Struct<{
+  readonly status: S.Literal<"ignored">;
+  readonly reason: S.optional<S.Unknown>;
+}>]>;
+type CheckAnswer = typeof CheckAnswerSchema.Type;
 declare const CheckStatus: S.Literals<readonly ["passed", "compileError", "ignored"]>;
 type CheckStatus = typeof CheckStatus.Type;
 declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
   readonly cause: S.String;
   readonly checkerName: S.String;
   readonly mutantIds: S.$Array<S.brand<S.String, "MutantId">>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class CheckerFailed extends CheckerFailed_base {
   get message(): string;
 }
@@ -1390,11 +1417,12 @@ interface CheckerService {
   readonly init: Effect$1.Effect<void, CheckerFailed>;
   readonly check: (mutants: readonly CheckerMutantWire[]) => Effect$1.Effect<HashMap.HashMap<string, CheckResult>, CheckerFailed>;
   readonly group: (mutants: readonly CheckerMutantWire[]) => Effect$1.Effect<readonly (readonly string[])[], CheckerFailed>;
+  readonly digest: Effect$1.Effect<ProgramDigest, CheckerFailed>;
 }
 declare const Checker_base: Context.ServiceClass<Checker, "@systemfsoftware/stryker-js-plugin-interface/Checker.service/Checker", CheckerService>;
 declare class Checker extends Checker_base {}
 declare namespace mod_d_exports {
-  export { CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerMutantWire, CheckerService, FailedCheckResult, IgnoredCheckResult, PassedCheckResult };
+  export { CheckAnswer, CheckAnswerSchema, CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerMutantWire, CheckerService, FailedCheckResult, IgnoredCheckResult, PassedCheckResult, ProgramDigest };
 }
 //#endregion
 //#region src/Mutant.schema.d.ts
@@ -1402,18 +1430,85 @@ declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "No
 type MutantStatus = typeof MutantStatusSchema.Type;
 declare const SurvivorStatusSchema: S.Literals<readonly ["Survived", "NoCoverage"]>;
 type SurvivorStatus = typeof SurvivorStatusSchema.Type;
-declare const RememberedStatusSchema: S.Literals<readonly ["Survived", "Killed", "Timeout", "NoCoverage", "Ignored"]>;
+declare const RememberedStatusSchema: S.Literals<readonly ["Survived", "Killed", "Timeout", "NoCoverage", "Ignored", "CompileError"]>;
 type RememberedStatus = typeof RememberedStatusSchema.Type;
 declare const EphemeralStatusSchema: S.Literals<readonly ["CompileError", "RuntimeError", "Pending"]>;
 type EphemeralStatus = typeof EphemeralStatusSchema.Type;
 declare const ActionableStatusSchema: S.Literals<readonly ["Survived", "NoCoverage", "Timeout", "RuntimeError"]>;
 type ActionableStatus = typeof ActionableStatusSchema.Type;
+declare const SettledStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Pending"]>;
+type SettledStatus = typeof SettledStatusSchema.Type;
 declare const MutantId: S.brand<S.String, "MutantId">;
 type MutantId = typeof MutantId.Type;
 declare const MutatorName: S.brand<S.String, "MutatorName">;
 type MutatorName = typeof MutatorName.Type;
 declare const CanonicalFileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
 type CanonicalFileName = typeof CanonicalFileName.Type;
+declare const Subsumed: S.TaggedStruct<"Subsumed", {
+  readonly rule: S.Literals<readonly ["complement"]>;
+  readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
+}>;
+type Subsumed = typeof Subsumed.Type;
+declare const subsumedStatusReason: (subsumed: Subsumed) => string;
+/**
+ * Why a subsumed mutant ran after all: none of its dominators ran, and each
+ * cause names one dominator and why it did not run, in `dominators` order.
+ */
+declare const ReadmitCauseCode: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+type ReadmitCauseCode = typeof ReadmitCauseCode.Type;
+declare const Readmitted: S.TaggedStruct<"Readmitted", {
+  readonly rule: S.Literals<readonly ["complement"]>;
+  readonly causes: S.NonEmptyArray<S.Struct<{
+    readonly dominator: S.brand<S.String, "MutantId">;
+    readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+    readonly detail: S.String;
+  }>>;
+}>;
+type Readmitted = typeof Readmitted.Type;
+declare const Subsumption: S.Union<readonly [S.TaggedStruct<"Subsumed", {
+  readonly rule: S.Literals<readonly ["complement"]>;
+  readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
+}>, S.TaggedStruct<"Readmitted", {
+  readonly rule: S.Literals<readonly ["complement"]>;
+  readonly causes: S.NonEmptyArray<S.Struct<{
+    readonly dominator: S.brand<S.String, "MutantId">;
+    readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+    readonly detail: S.String;
+  }>>;
+}>]>;
+type Subsumption = typeof Subsumption.Type;
+declare const ProbeKind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+type ProbeKind = typeof ProbeKind.Type;
+declare const Probed: S.TaggedStruct<"Probed", {
+  readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+}>;
+type Probed = typeof Probed.Type;
+/**
+ * Why a mutant carries no probe and runs exactly as it would without one:
+ * - `mutator-not-probed`: its mutator is outside the probed set.
+ * - `operator-not-probed`: its mutator is probed, but not for this original operator.
+ * - `every-reach-infects`: an `==`/`!=`/`===`/`!==` swap changes the value on every evaluation.
+ * - `not-a-comparison`: a constant replacement of an expression that is not a comparison.
+ * - `operand-not-proven-local`: a constant replacement of a comparison whose operand may run user code.
+ * - `shape-not-recognized`: the original and replacement nodes do not have the probed form.
+ * - `not-decided`: the mutant was built or decoded without an eligibility decision.
+ */
+declare const UnprobedReason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+type UnprobedReason = typeof UnprobedReason.Type;
+declare const Unprobed: S.TaggedStruct<"Unprobed", {
+  readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+}>;
+type Unprobed = typeof Unprobed.Type;
+declare const ProbeEligibility: S.Union<readonly [S.TaggedStruct<"Probed", {
+  readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+}>, S.TaggedStruct<"Unprobed", {
+  readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+}>]>;
+type ProbeEligibility = typeof ProbeEligibility.Type;
+declare const subsumptionMatchesStatus: {
+  (status: MutantStatus | undefined): (subsumption: Subsumption) => boolean;
+  (subsumption: Subsumption, status: MutantStatus | undefined): boolean;
+};
 /**
  * A mutant's file location in the mutation-testing-report-schema contract:
  * 1-based line and 1-based column, the same base the JSON report and the
@@ -1460,6 +1555,22 @@ declare const Mutant: S.Struct<{
   readonly static: S.optional<S.Boolean>;
   readonly testsCompleted: S.optional<S.Finite>;
   readonly description: S.optional<S.String>;
+  readonly subsumption: S.optional<S.Union<readonly [S.TaggedStruct<"Subsumed", {
+    readonly rule: S.Literals<readonly ["complement"]>;
+    readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
+  }>, S.TaggedStruct<"Readmitted", {
+    readonly rule: S.Literals<readonly ["complement"]>;
+    readonly causes: S.NonEmptyArray<S.Struct<{
+      readonly dominator: S.brand<S.String, "MutantId">;
+      readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+      readonly detail: S.String;
+    }>>;
+  }>]>>;
+  readonly probeEligibility: S.withDecodingDefaultKey<S.withConstructorDefault<S.Union<readonly [S.TaggedStruct<"Probed", {
+    readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+  }>, S.TaggedStruct<"Unprobed", {
+    readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+  }>]>>, never>;
 }>;
 type Mutant = typeof Mutant.Type;
 declare const MutantFromUnknown: S.compose<S.Struct<{
@@ -1502,6 +1613,22 @@ declare const MutantFromUnknown: S.compose<S.Struct<{
   readonly static: S.optional<S.Boolean>;
   readonly testsCompleted: S.optional<S.Finite>;
   readonly description: S.optional<S.String>;
+  readonly subsumption: S.optional<S.Union<readonly [S.TaggedStruct<"Subsumed", {
+    readonly rule: S.Literals<readonly ["complement"]>;
+    readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
+  }>, S.TaggedStruct<"Readmitted", {
+    readonly rule: S.Literals<readonly ["complement"]>;
+    readonly causes: S.NonEmptyArray<S.Struct<{
+      readonly dominator: S.brand<S.String, "MutantId">;
+      readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+      readonly detail: S.String;
+    }>>;
+  }>]>>;
+  readonly probeEligibility: S.withDecodingDefaultKey<S.withConstructorDefault<S.Union<readonly [S.TaggedStruct<"Probed", {
+    readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+  }>, S.TaggedStruct<"Unprobed", {
+    readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+  }>]>>, never>;
 }>, S.Unknown>;
 type MutantFromUnknown = typeof MutantFromUnknown.Type;
 declare const RunOptionsFields: {
@@ -1554,6 +1681,22 @@ declare const MutantRunOptionsSchema: S.Struct<{
     readonly static: S.optional<S.Boolean>;
     readonly testsCompleted: S.optional<S.Finite>;
     readonly description: S.optional<S.String>;
+    readonly subsumption: S.optional<S.Union<readonly [S.TaggedStruct<"Subsumed", {
+      readonly rule: S.Literals<readonly ["complement"]>;
+      readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
+    }>, S.TaggedStruct<"Readmitted", {
+      readonly rule: S.Literals<readonly ["complement"]>;
+      readonly causes: S.NonEmptyArray<S.Struct<{
+        readonly dominator: S.brand<S.String, "MutantId">;
+        readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+        readonly detail: S.String;
+      }>>;
+    }>]>>;
+    readonly probeEligibility: S.withDecodingDefaultKey<S.withConstructorDefault<S.Union<readonly [S.TaggedStruct<"Probed", {
+      readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+    }>, S.TaggedStruct<"Unprobed", {
+      readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+    }>]>>, never>;
   }>;
   readonly sandboxFileName: S.String;
   readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
@@ -2047,14 +2190,64 @@ type ExitClass = typeof ExitClass.Type;
 declare const ExitCodeFromClass: S.decodeTo<S.Literals<readonly [1, 2, 3, 4]>, S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>, never, never>;
 //#endregion
 //#region src/ignore-rule.schema.d.ts
-declare const IgnoreRuleId: S.Literals<readonly ["arid-logging", "arid-telemetry", "arid-time", "arid-config-default", "arid-memoization", "redundant-relational", "equivalent-to-original", "duplicate-at-site", "ignore-static", "directive", "excluded-mutator", "ignorer"]>;
+declare const IgnoreRuleId: S.Union<readonly (S.Literal<"arid-config-default"> | S.Literal<"arid-logging"> | S.Literal<"arid-memoization"> | S.Literal<"arid-telemetry"> | S.Literal<"arid-time"> | S.Literal<"checker"> | S.Literal<"directive"> | S.Literal<"duplicate-at-site"> | S.Literal<"equivalent-to-original"> | S.Literal<"excluded-mutator"> | S.Literal<"ignore-static"> | S.Literal<"ignorer"> | S.Literal<"redundant-relational">)[]>;
 type IgnoreRuleId = typeof IgnoreRuleId.Type;
+declare const SettledReasonCode: S.Union<readonly S.Literal<"compile-error" | "coverage-not-measured" | "covered-not-killed" | "killed" | "not-covered" | "remembered" | "runtime-error" | "timed-out">[]>;
+type SettledReasonCode = typeof SettledReasonCode.Type;
+declare const RunFailureCode: S.Union<readonly (S.Literal<"budget-exceeded"> | S.Literal<"config-invalid"> | S.Literal<"initial-test-run-failed"> | S.Literal<"mutation-runs-on-main-ci"> | S.Literal<"new-survivors"> | S.Literal<"plugin-load-failed"> | S.Literal<"score-below-break"> | S.Literal<"shard-reports-missing"> | S.Literal<"shard-reports-overlap">)[]>;
+type RunFailureCode = typeof RunFailureCode.Type;
+declare const ToolRefusalCode: S.Union<readonly (S.Literal<"cursor-stale"> | S.Literal<"report-missing"> | S.Literal<"report-unreadable"> | S.Literal<"rerun-refused"> | S.Literal<"unknown-mutant-id">)[]>;
+type ToolRefusalCode = typeof ToolRefusalCode.Type;
 declare const IgnoreStatusReasonText: S.String;
 declare const IgnoreStatusReason: S.decodeTo<S.Struct<{
-  readonly ruleId: S.Literals<readonly ["arid-logging", "arid-telemetry", "arid-time", "arid-config-default", "arid-memoization", "redundant-relational", "equivalent-to-original", "duplicate-at-site", "ignore-static", "directive", "excluded-mutator", "ignorer"]>;
+  readonly code: S.Union<readonly (S.Literal<"arid-config-default"> | S.Literal<"arid-logging"> | S.Literal<"arid-memoization"> | S.Literal<"arid-telemetry"> | S.Literal<"arid-time"> | S.Literal<"checker"> | S.Literal<"directive"> | S.Literal<"duplicate-at-site"> | S.Literal<"equivalent-to-original"> | S.Literal<"excluded-mutator"> | S.Literal<"ignore-static"> | S.Literal<"ignorer"> | S.Literal<"redundant-relational">)[]>;
   readonly detail: S.String;
 }>, S.String, never, never>;
 type IgnoreStatusReason = typeof IgnoreStatusReason.Type;
+declare const StatusReason: S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"Ignored">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Union<readonly (S.Literal<"arid-config-default"> | S.Literal<"arid-logging"> | S.Literal<"arid-memoization"> | S.Literal<"arid-telemetry"> | S.Literal<"arid-time"> | S.Literal<"checker"> | S.Literal<"directive"> | S.Literal<"duplicate-at-site"> | S.Literal<"equivalent-to-original"> | S.Literal<"excluded-mutator"> | S.Literal<"ignore-static"> | S.Literal<"ignorer"> | S.Literal<"redundant-relational">)[]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>, S.Struct<{
+  readonly status: S.Literal<"Killed">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Literals<readonly ["killed", "remembered"]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>, S.Struct<{
+  readonly status: S.Literal<"Survived">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Literals<readonly ["covered-not-killed", "coverage-not-measured", "remembered"]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>, S.Struct<{
+  readonly status: S.Literal<"NoCoverage">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Literals<readonly ["not-covered", "remembered"]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>, S.Struct<{
+  readonly status: S.Literal<"Timeout">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Literals<readonly ["timed-out", "remembered"]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>, S.Struct<{
+  readonly status: S.Literal<"RuntimeError">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Literals<readonly ["runtime-error"]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>, S.Struct<{
+  readonly status: S.Literal<"CompileError">;
+  readonly statusReason: S.decodeTo<S.Struct<{
+    readonly code: S.Literals<readonly ["compile-error", "remembered"]>;
+    readonly detail: S.String;
+  }>, S.String, never, never>;
+}>]>;
+type StatusReason = typeof StatusReason.Type;
 //#endregion
 //#region src/Location.schema.d.ts
 /** A 1-based line: the first line of a file is line 1. */
@@ -2072,8 +2265,8 @@ interface Ends<A> {
   readonly start: A;
   readonly end: A;
 }
-declare const inOrder: <A>(order: Order.Order<A>) => (ends: Ends<A>) => Ends<A>;
-declare const notReversed: <A>(order: Order.Order<A>) => (ends: Ends<A>) => boolean;
+declare const inOrder: <A>(order: Order$1.Order<A>) => (ends: Ends<A>) => Ends<A>;
+declare const notReversed: <A>(order: Order$1.Order<A>) => (ends: Ends<A>) => boolean;
 declare const Location: S.decodeTo<S.declare<{
   readonly start: {
     readonly line: number;
@@ -2135,16 +2328,16 @@ type OpenEndLocation = typeof OpenEndLocation.Type;
 type CatalogText = string;
 declare const duplicatedValue: (values: readonly CatalogText[]) => string | undefined;
 declare namespace mod_d_exports$2 {
-  export { ActionableStatus, ActionableStatusSchema, CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Column, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, Ends, EphemeralStatus, EphemeralStatusSchema, HitCount, IgnoreRuleId, IgnoreRuleId as IgnoreRuleIdValue, IgnoreStatusReason, IgnoreStatusReasonText, IgnoreStatusReason as IgnoreStatusReasonValue, Line, Location, Mutant, MutantActivation, MutantActivationSchema, MutantCost, MutantCoverage, MutantCoverageSchema, MutantEarlyResultPlan, MutantFromUnknown, MutantFromUnknown as MutantFromUnknownValue, MutantId, MutantId as MutantIdValue, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutatorName, MutatorName as MutatorNameValue, OpenEndLocation, Position, RememberedStatus, RememberedStatusSchema, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, SurvivorStatus, SurvivorStatusSchema, TestPlan, duplicatedValue, inOrder, notReversed };
+  export { ActionableStatus, ActionableStatusSchema, CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Column, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, Ends, EphemeralStatus, EphemeralStatusSchema, HitCount, IgnoreRuleId, IgnoreRuleId as IgnoreRuleIdValue, IgnoreStatusReason, IgnoreStatusReasonText, IgnoreStatusReason as IgnoreStatusReasonValue, Line, Location, Mutant, MutantActivation, MutantActivationSchema, MutantCost, MutantCoverage, MutantCoverageSchema, MutantEarlyResultPlan, MutantFromUnknown, MutantFromUnknown as MutantFromUnknownValue, MutantId, MutantId as MutantIdValue, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutatorName, MutatorName as MutatorNameValue, OpenEndLocation, Position, ProbeEligibility, ProbeKind, Probed, ReadmitCauseCode, Readmitted, RememberedStatus, RememberedStatusSchema, RunFailureCode, RunFailureCode as RunFailureCodeValue, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, SettledReasonCode, SettledReasonCode as SettledReasonCodeValue, SettledStatus, SettledStatusSchema, StatusReason, StatusReason as StatusReasonValue, Subsumed, Subsumption, SurvivorStatus, SurvivorStatusSchema, TestPlan, ToolRefusalCode, ToolRefusalCode as ToolRefusalCodeValue, Unprobed, UnprobedReason, duplicatedValue, inOrder, notReversed, subsumedStatusReason, subsumptionMatchesStatus };
 }
 //#endregion
 //#region src/MutatorProvider.schema.d.ts
 interface MutatorContext {
-  readonly parent: Node_2 | undefined;
-  readonly grandParent: Node_2 | undefined;
-  readonly ancestors: readonly Node_2[];
+  readonly parent: Node | undefined;
+  readonly grandParent: Node | undefined;
+  readonly ancestors: readonly Node[];
 }
-type Mutator = (node: Node_2, context: MutatorContext) => Iterable<Node_2>;
+type Mutator = (node: Node, context: MutatorContext) => Iterable<Node>;
 declare const Implementation: Schema.declare<Mutator, Mutator>;
 declare const ProviderEntry: Schema.Struct<{
   readonly id: Schema.brand<Schema.String, "MutatorCatalogId">;
@@ -2385,7 +2578,9 @@ declare const Metrics_base: S.Class<Metrics, S.Struct<{
   readonly runtimeErrors: S.Int;
   readonly compileErrors: S.Int;
   readonly ignored: S.Int;
-}>, {}>;
+}>, {
+  readonly brand: unique symbol;
+}>;
 declare class Metrics extends Metrics_base {
   get totalDetected(): number;
   get totalUndetected(): number;
@@ -2464,7 +2659,9 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
     }>>;
     readonly status: S.Literal<"success">;
   }>]>>;
-}>, {}>;
+}>, {
+  readonly brand: unique symbol;
+}>;
 declare class DryRunCompleted extends DryRunCompleted_base {}
 declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
   readonly total: S.Int;
@@ -2474,7 +2671,9 @@ declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S
     readonly netTime: S.Finite;
     readonly reloadEnvironment: S.Boolean;
   }>>;
-}>, {}>;
+}>, {
+  readonly brand: unique symbol;
+}>;
 declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
 declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
   readonly id: S.brand<S.String, "MutantId">;
@@ -2512,7 +2711,9 @@ declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTes
   readonly replacement: S.NullOr<S.String>;
   readonly completed: S.Int;
   readonly total: S.Int;
-}>, {}>;
+}>, {
+  readonly brand: unique symbol;
+}>;
 declare class MutantTested extends MutantTested_base {}
 declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.TaggedStruct<"mutationTestReportReady", {
   readonly report: S.StructWithRest<S.Struct<{
@@ -2604,7 +2805,9 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
     readonly count: S.Int;
     readonly costMs: S.Finite;
   }>>;
-}>, {}>;
+}>, {
+  readonly brand: unique symbol;
+}>;
 declare class MutationTestReportReady extends MutationTestReportReady_base {}
 declare const ReporterEventUnion: S.toTaggedUnion<"_tag", readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
 type ReporterEvent = typeof ReporterEventUnion.Type;
@@ -2620,7 +2823,9 @@ declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"Repor
   readonly cause: S.String;
   readonly event: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
   readonly reporterName: S.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class ReporterFailed extends ReporterFailed_base {
   get message(): string;
 }
@@ -2705,6 +2910,7 @@ declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
     readonly static: S.decodeTo<S.$Record<S.brand<S.String, "MutantId">, S.Int>, S.$Record<S.String, S.Int>, never, never>;
   }>>;
   readonly globalTestInputs: S.optionalKey<S.$Array<S.String>>;
+  readonly testFileModules: S.optionalKey<S.$Record<S.String, S.$Array<S.String>>>;
 }>, S.Struct<{
   readonly status: S.Literal<"timeout">;
   readonly reason: S.optionalKey<S.String>;
@@ -2740,7 +2946,9 @@ declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
   readonly status: S.Literal<"error">;
   readonly errorMessage: S.String;
 }>]>;
-declare const MutantRunStarted_base: S.Class<MutantRunStarted, S.TaggedStruct<"MutantRunStarted", {}>, {}>;
+declare const MutantRunStarted_base: S.Class<MutantRunStarted, S.TaggedStruct<"MutantRunStarted", {}>, {
+  readonly brand: unique symbol;
+}>;
 declare class MutantRunStarted extends MutantRunStarted_base {}
 declare const MutantRunSettled_base: S.Class<MutantRunSettled, S.TaggedStruct<"MutantRunSettled", {
   readonly result: S.Union<readonly [S.Struct<{
@@ -2766,7 +2974,9 @@ declare const MutantRunSettled_base: S.Class<MutantRunSettled, S.TaggedStruct<"M
     readonly status: S.Literal<"error">;
     readonly errorMessage: S.String;
   }>]>;
-}>, {}>;
+}>, {
+  readonly brand: unique symbol;
+}>;
 declare class MutantRunSettled extends MutantRunSettled_base {}
 declare const MutantRunEventSchema: S.Union<readonly [typeof MutantRunStarted, typeof MutantRunSettled]>;
 type MutantRunEvent = typeof MutantRunEventSchema.Type;
@@ -2785,7 +2995,9 @@ declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"T
   readonly cause: S.String;
   readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
   readonly runnerName: S.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class TestRunnerFailed extends TestRunnerFailed_base {
   get message(): string;
 }
@@ -2811,6 +3023,7 @@ interface CompleteDryRunResult {
   readonly tests: readonly TestResult[];
   readonly mutantCoverage?: MutantCoverage;
   readonly globalTestInputs?: readonly string[];
+  readonly testFileModules?: Readonly<Record<string, readonly string[]>>;
   readonly status: 'complete';
 }
 interface TimeoutDryRunResult {
@@ -2914,6 +3127,22 @@ declare const TestRunnerMutantRunRequest: S.Struct<{
       readonly static: S.optional<S.Boolean>;
       readonly testsCompleted: S.optional<S.Finite>;
       readonly description: S.optional<S.String>;
+      readonly subsumption: S.optional<S.Union<readonly [S.TaggedStruct<"Subsumed", {
+        readonly rule: S.Literals<readonly ["complement"]>;
+        readonly dominators: S.NonEmptyArray<S.brand<S.String, "MutantId">>;
+      }>, S.TaggedStruct<"Readmitted", {
+        readonly rule: S.Literals<readonly ["complement"]>;
+        readonly causes: S.NonEmptyArray<S.Struct<{
+          readonly dominator: S.brand<S.String, "MutantId">;
+          readonly code: S.Literals<readonly ["dominator-ignored-at-check", "dominator-compile-error", "dominator-ignored-at-plan", "dominator-remembered-without-running", "dominator-unsettled"]>;
+          readonly detail: S.String;
+        }>>;
+      }>]>>;
+      readonly probeEligibility: S.withDecodingDefaultKey<S.withConstructorDefault<S.Union<readonly [S.TaggedStruct<"Probed", {
+        readonly kind: S.Literals<readonly ["arithmetic", "relational", "unary", "constant"]>;
+      }>, S.TaggedStruct<"Unprobed", {
+        readonly reason: S.Literals<readonly ["mutator-not-probed", "operator-not-probed", "every-reach-infects", "not-a-comparison", "operand-not-proven-local", "shape-not-recognized", "not-decided"]>;
+      }>]>>, never>;
     }>;
     readonly sandboxFileName: S.String;
     readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
@@ -2969,9 +3198,13 @@ declare const CheckerCheckResult: S.$Record<S.String, S.toTaggedUnion<"status",
   readonly reason: S.String;
 }>, S.Struct<{
   readonly status: S.Literal<"ignored">;
-  readonly reason: S.String;
+  readonly reason: S.optional<S.Unknown>;
 }>]>>;
 declare const CheckerGroupResult: S.$Array<S.$Array<S.String>>;
+declare const CheckerDigestRequest: S.Struct<{
+  readonly checkerName: S.String;
+}>;
+type CheckerDigestRequest = typeof CheckerDigestRequest.Type;
 declare const ReporterInitOptions: S.Struct<{
   readonly traceparent: S.optionalKey<S.decodeTo<S.Struct<{
     readonly version: S.String;
@@ -2990,7 +3223,9 @@ declare const BoundaryPayloadRejected_base: S.Class<BoundaryPayloadRejected, S.T
   readonly pluginName: S.String;
   readonly method: S.String;
   readonly cause: S.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class BoundaryPayloadRejected extends BoundaryPayloadRejected_base {
   get message(): string;
 }
@@ -2998,7 +3233,9 @@ declare const BoundaryUnrecognizedSignal_base: S.Class<BoundaryUnrecognizedSigna
   readonly pluginName: S.String;
   readonly method: S.String;
   readonly signal: S.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class BoundaryUnrecognizedSignal extends BoundaryUnrecognizedSignal_base {
   get message(): string;
 }
@@ -3024,6 +3261,112 @@ declare class PropagatedTrace extends PropagatedTrace_base {}
 declare const TraceContextMiddleware_base: RpcMiddleware.ServiceClass<TraceContextMiddleware, "@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", typeof PropagatedTrace, Schema.Never, never, never, true>;
 declare class TraceContextMiddleware extends TraceContextMiddleware_base {}
 type TracedRpc<Tag extends string, Payload extends Schema.Top = Schema.Void, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> = Rpc.AddMiddleware<Rpc.Rpc<Tag, Payload, Success, Error>, typeof TraceContextMiddleware>;
+declare const TypeQueryRequest: S.Struct<{
+  readonly version: S.Int;
+  readonly tsconfigFile: S.String;
+  readonly files: S.NonEmptyArray<S.Struct<{
+    readonly fileName: S.String;
+    readonly content: S.String;
+    readonly sites: S.$Array<S.Struct<{
+      readonly siteId: S.String;
+      readonly kind: S.Literals<readonly ["expression", "function-body"]>;
+      readonly location: S.decodeTo<S.declare<{
+        readonly start: {
+          readonly line: number;
+          readonly column: number;
+        };
+        readonly end: {
+          readonly line: number;
+          readonly column: number;
+        };
+      }, {
+        readonly start: {
+          readonly line: number;
+          readonly column: number;
+        };
+        readonly end: {
+          readonly line: number;
+          readonly column: number;
+        };
+      }>, S.Struct<{
+        readonly start: S.Struct<{
+          readonly line: S.Int;
+          readonly column: S.Int;
+        }>;
+        readonly end: S.Struct<{
+          readonly line: S.Int;
+          readonly column: S.Int;
+        }>;
+      }>, never, never>;
+      readonly candidates: S.$Array<S.Struct<{
+        readonly candidateId: S.String;
+        readonly text: S.String;
+      }>>;
+    }>>;
+  }>>;
+}>;
+type TypeQueryRequest = typeof TypeQueryRequest.Type;
+declare const TypeAnswerTypeId: unique symbol;
+type TypeAnswerTypeId = typeof TypeAnswerTypeId;
+declare const Assignable_base: S.Class<Assignable, S.TaggedStruct<"Assignable", {
+  readonly candidateType: S.String;
+}>, {
+  readonly brand: unique symbol;
+}>;
+declare class Assignable extends Assignable_base {
+  readonly [TypeAnswerTypeId]: symbol;
+}
+declare const NotAssignable_base: S.Class<NotAssignable, S.TaggedStruct<"NotAssignable", {
+  readonly candidateType: S.String;
+  readonly contextualType: S.String;
+}>, {
+  readonly brand: unique symbol;
+}>;
+declare class NotAssignable extends NotAssignable_base {
+  readonly [TypeAnswerTypeId]: symbol;
+}
+declare const Unknown_base: S.Class<Unknown, S.TaggedStruct<"Unknown", {
+  readonly reason: S.Literals<readonly ["candidate-not-context-free", "candidate-not-found", "site-not-found", "site-not-expression", "no-contextual-type", "error-type", "instantiable-target", "overloaded-or-generic-call", "context-not-enforced", "site-not-function-body", "candidate-not-empty-body", "return-type-not-declared", "generator-body", "constructor-body", "getter-requires-return", "implicit-return-rejected", "async-return-not-promise"]>;
+}>, {
+  readonly brand: unique symbol;
+}>;
+declare class Unknown extends Unknown_base {
+  readonly [TypeAnswerTypeId]: symbol;
+}
+declare const TypeQueryResponse: S.Struct<{
+  readonly version: S.Literals<readonly [1, 2]>;
+  readonly files: S.$Array<S.Union<readonly [S.TaggedStruct<"FileAnswered", {
+    readonly fileName: S.String;
+    readonly sites: S.$Array<S.Struct<{
+      readonly siteId: S.String;
+      readonly siteType: S.OptionFromNullOr<S.String>;
+      readonly contextualType: S.OptionFromNullOr<S.String>;
+      readonly candidates: S.$Array<S.Struct<{
+        readonly candidateId: S.String;
+        readonly answer: S.Union<readonly [typeof Assignable, typeof NotAssignable, typeof Unknown]>;
+      }>>;
+    }>>;
+  }>, S.TaggedStruct<"FileRefused", {
+    readonly fileName: S.String;
+    readonly reason: S.Literals<readonly ["not-in-project", "server-crashed", "query-timed-out"]>;
+    readonly nextAction: S.String;
+  }>]>>;
+}>;
+type TypeQueryResponse = typeof TypeQueryResponse.Type;
+declare const TypeQueryRefused_base: S.Class<TypeQueryRefused, S.TaggedStruct<"TypeQueryRefused", {
+  readonly version: S.Int;
+  readonly reason: S.Literals<readonly ["unsupported-version", "project-open-failed"]>;
+  readonly nextAction: S.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+declare class TypeQueryRefused extends TypeQueryRefused_base {
+  get message(): string;
+}
+declare const CheckerCapabilities: S.Struct<{
+  readonly typeQuery: S.$Array<S.Int>;
+}>;
+type CheckerCapabilities = typeof CheckerCapabilities.Type;
 //#endregion
 //#region src/PluginRpcs.service.d.ts
 declare const capabilities: TracedRpc<'capabilities', Schema.Void, typeof TestRunnerCapabilitiesSchema, typeof TestRunnerFailed>;
@@ -3031,14 +3374,17 @@ declare const dryRun: TracedRpc<'dryRun', typeof TestRunnerDryRunRequest, typeof
 declare const mutantRun: TracedRpc<'mutantRun', typeof TestRunnerMutantRunRequest, RpcSchema.Stream<typeof MutantRunEventSchema, typeof TestRunnerFailed>, typeof Schema.Never>;
 declare const check: TracedRpc<'check', typeof CheckerRequest, typeof CheckerCheckResult, typeof CheckerFailed>;
 declare const group: TracedRpc<'group', typeof CheckerRequest, typeof CheckerGroupResult, typeof CheckerFailed>;
+declare const digest: TracedRpc<'digest', typeof CheckerDigestRequest, typeof ProgramDigest, typeof CheckerFailed>;
+declare const checkerCapabilities: TracedRpc<'capabilities', typeof CheckerDigestRequest, typeof CheckerCapabilities, typeof CheckerFailed>;
+declare const typeQuery: TracedRpc<'typeQuery', typeof TypeQueryRequest, typeof TypeQueryResponse, typeof TypeQueryRefused>;
 declare const init: TracedRpc<'init', typeof ReporterInitOptions, typeof ReporterAck, typeof ReporterFailed>;
 declare const onEventBatch: TracedRpc<'onEventBatch', typeof ReporterEventBatch, typeof ReporterAck, typeof ReporterFailed>;
 declare const flush: TracedRpc<'flush', Schema.Void, typeof ReporterDrained, typeof ReporterFailed>;
 declare const TestRunnerRpcs: RpcGroup.RpcGroup<typeof capabilities | typeof dryRun | typeof mutantRun>;
-declare const CheckerRpcs: RpcGroup.RpcGroup<typeof check | typeof group>;
+declare const CheckerRpcs: RpcGroup.RpcGroup<typeof check | typeof group | typeof digest | typeof checkerCapabilities | typeof typeQuery>;
 declare const ReporterRpcs: RpcGroup.RpcGroup<typeof init | typeof onEventBatch | typeof flush>;
 declare namespace mod_d_exports$6 {
-  export { BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, CheckerCheckResult, CheckerGroupResult, CheckerRequest, CheckerRpcs, EvaluatorPluginKind, ExitClass, ExitCode, ExitCodeFromClass, PluginKind, PluginKindSchema, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, TestRunnerDryRunRequest, TestRunnerMutantRunRequest, TestRunnerRpcs, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema };
+  export { BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, CheckerCheckResult, CheckerDigestRequest, CheckerGroupResult, CheckerRequest, CheckerRpcs, EvaluatorPluginKind, ExitClass, ExitCode, ExitCodeFromClass, PluginKind, PluginKindSchema, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, TestRunnerDryRunRequest, TestRunnerMutantRunRequest, TestRunnerRpcs, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema };
 }
 //#endregion
 //#region src/Metrics.d.ts
@@ -3078,4 +3424,4 @@ declare namespace mod_d_exports$9 {
   export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, ExecutedTest, ExecutedTestSchema, FailedTestResult, HitLimitReason, HitLimitReasonPrefix, HitLimitReasonText, KilledMutantRunResult, MutantRunEvent, MutantRunEventSchema, MutantRunResult, MutantRunResultSchema, MutantRunSettled, MutantRunStarted, MutantRunStatus, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestId, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, WallClockTimeoutReason };
 }
 //#endregion
-export { mod_d_exports$6 as a, mod_d_exports$9 as c, Program as d, Statement as f, mod_d_exports$5 as i, Ignorer as l, mod_d_exports$2 as n, mod_d_exports$7 as o, mod_d_exports$4 as r, mod_d_exports$8 as s, mod_d_exports as t, Node_2 as u };
+export { mod_d_exports$6 as a, mod_d_exports$9 as c, Program as d, Statement as f, mod_d_exports$5 as i, Ignorer as l, mod_d_exports$2 as n, mod_d_exports$7 as o, mod_d_exports$4 as r, mod_d_exports$8 as s, mod_d_exports as t, Node as u };