@coana-tech/cli 14.12.194 → 14.12.195

package/repos/coana-tech/jelly-private/dist/bundle/node_modules/@babel/types/lib/index-legacy.d.ts

@@ -46,7 +46,7 @@ export type Node = Accessor | AnyTypeAnnotation | ArgumentPlaceholder | ArrayExp
 
 export interface ArrayExpression extends BaseNode {
   type: "ArrayExpression";
-  elements: Array<null | Expression | SpreadElement>;
+  elements: (null | Expression | SpreadElement)[];
 }
 
 export interface AssignmentExpression extends BaseNode {
@@ -80,8 +80,8 @@ export interface DirectiveLiteral extends BaseNode {
 
 export interface BlockStatement extends BaseNode {
   type: "BlockStatement";
-  body: Array<Statement>;
-  directives: Array<Directive>;
+  body: Statement[];
+  directives: Directive[];
 }
 
 export interface BreakStatement extends BaseNode {
@@ -92,7 +92,7 @@ export interface BreakStatement extends BaseNode {
 export interface CallExpression extends BaseNode {
   type: "CallExpression";
   callee: Expression | Super | V8IntrinsicIdentifier;
-  arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>;
+  arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
   optional: boolean | null;
   typeArguments: TypeParameterInstantiation | null;
   typeParameters: TSTypeParameterInstantiation | null;
@@ -138,8 +138,8 @@ export interface ExpressionStatement extends BaseNode {
 export interface File extends BaseNode {
   type: "File";
   program: Program;
-  comments: Array<CommentBlock | CommentLine> | null;
-  tokens: Array<any> | null;
+  comments: (CommentBlock | CommentLine)[] | null;
+  tokens: any[] | null;
 }
 
 export interface ForInStatement extends BaseNode {
@@ -160,7 +160,7 @@ export interface ForStatement extends BaseNode {
 export interface FunctionDeclaration extends BaseNode {
   type: "FunctionDeclaration";
   id: Identifier | null;
-  params: Array<FunctionParameter>;
+  params: FunctionParameter[];
   body: BlockStatement;
   generator: boolean;
   async: boolean;
@@ -173,7 +173,7 @@ export interface FunctionDeclaration extends BaseNode {
 export interface FunctionExpression extends BaseNode {
   type: "FunctionExpression";
   id: Identifier | null;
-  params: Array<FunctionParameter>;
+  params: FunctionParameter[];
   body: BlockStatement;
   generator: boolean;
   async: boolean;
@@ -185,7 +185,7 @@ export interface FunctionExpression extends BaseNode {
 export interface Identifier extends BaseNode {
   type: "Identifier";
   name: string;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   optional: boolean | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -246,7 +246,7 @@ export interface MemberExpression extends BaseNode {
 export interface NewExpression extends BaseNode {
   type: "NewExpression";
   callee: Expression | Super | V8IntrinsicIdentifier;
-  arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>;
+  arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
   optional: boolean | null;
   typeArguments: TypeParameterInstantiation | null;
   typeParameters: TSTypeParameterInstantiation | null;
@@ -254,27 +254,27 @@ export interface NewExpression extends BaseNode {
 
 export interface Program extends BaseNode {
   type: "Program";
-  body: Array<Statement>;
-  directives: Array<Directive>;
+  body: Statement[];
+  directives: Directive[];
   sourceType: "script" | "module";
   interpreter: InterpreterDirective | null;
 }
 
 export interface ObjectExpression extends BaseNode {
   type: "ObjectExpression";
-  properties: Array<ObjectMethod | ObjectProperty | SpreadElement>;
+  properties: (ObjectMethod | ObjectProperty | SpreadElement)[];
 }
 
 export interface ObjectMethod extends BaseNode {
   type: "ObjectMethod";
   kind: "method" | "get" | "set";
   key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
-  params: Array<FunctionParameter>;
+  params: FunctionParameter[];
   body: BlockStatement;
   computed: boolean;
   generator: boolean;
   async: boolean;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
   typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
 }
@@ -285,13 +285,13 @@ export interface ObjectProperty extends BaseNode {
   value: Expression | PatternLike;
   computed: boolean;
   shorthand: boolean;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
 }
 
 export interface RestElement extends BaseNode {
   type: "RestElement";
   argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   optional: boolean | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -303,7 +303,7 @@ export interface ReturnStatement extends BaseNode {
 
 export interface SequenceExpression extends BaseNode {
   type: "SequenceExpression";
-  expressions: Array<Expression>;
+  expressions: Expression[];
 }
 
 export interface ParenthesizedExpression extends BaseNode {
@@ -314,13 +314,13 @@ export interface ParenthesizedExpression extends BaseNode {
 export interface SwitchCase extends BaseNode {
   type: "SwitchCase";
   test: Expression | null;
-  consequent: Array<Statement>;
+  consequent: Statement[];
 }
 
 export interface SwitchStatement extends BaseNode {
   type: "SwitchStatement";
   discriminant: Expression;
-  cases: Array<SwitchCase>;
+  cases: SwitchCase[];
 }
 
 export interface ThisExpression extends BaseNode {
@@ -356,7 +356,7 @@ export interface UpdateExpression extends BaseNode {
 export interface VariableDeclaration extends BaseNode {
   type: "VariableDeclaration";
   kind: "var" | "let" | "const" | "using" | "await using";
-  declarations: Array<VariableDeclarator>;
+  declarations: VariableDeclarator[];
   declare: boolean | null;
 }
 
@@ -383,22 +383,22 @@ export interface AssignmentPattern extends BaseNode {
   type: "AssignmentPattern";
   left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
   right: Expression;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   optional: boolean | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
 
 export interface ArrayPattern extends BaseNode {
   type: "ArrayPattern";
-  elements: Array<null | PatternLike>;
-  decorators: Array<Decorator> | null;
+  elements: (null | PatternLike)[];
+  decorators: Decorator[] | null;
   optional: boolean | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
 
 export interface ArrowFunctionExpression extends BaseNode {
   type: "ArrowFunctionExpression";
-  params: Array<FunctionParameter>;
+  params: FunctionParameter[];
   body: BlockStatement | Expression;
   async: boolean;
   expression: boolean;
@@ -410,7 +410,7 @@ export interface ArrowFunctionExpression extends BaseNode {
 
 export interface ClassBody extends BaseNode {
   type: "ClassBody";
-  body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>;
+  body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[];
 }
 
 export interface ClassExpression extends BaseNode {
@@ -418,8 +418,8 @@ export interface ClassExpression extends BaseNode {
   id: Identifier | null;
   superClass: Expression | null;
   body: ClassBody;
-  decorators: Array<Decorator> | null;
-  implements: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
+  decorators: Decorator[] | null;
+  implements: (TSExpressionWithTypeArguments | ClassImplements)[] | null;
   mixins: InterfaceExtends | null;
   superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
   typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
@@ -430,10 +430,10 @@ export interface ClassDeclaration extends BaseNode {
   id: Identifier | null;
   superClass: Expression | null;
   body: ClassBody;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   abstract: boolean | null;
   declare: boolean | null;
-  implements: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
+  implements: (TSExpressionWithTypeArguments | ClassImplements)[] | null;
   mixins: InterfaceExtends | null;
   superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
   typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
@@ -442,8 +442,8 @@ export interface ClassDeclaration extends BaseNode {
 export interface ExportAllDeclaration extends BaseNode {
   type: "ExportAllDeclaration";
   source: StringLiteral;
-  assertions: Array<ImportAttribute> | null;
-  attributes: Array<ImportAttribute> | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
   exportKind: "type" | "value" | null;
 }
 
@@ -456,10 +456,10 @@ export interface ExportDefaultDeclaration extends BaseNode {
 export interface ExportNamedDeclaration extends BaseNode {
   type: "ExportNamedDeclaration";
   declaration: Declaration | null;
-  specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>;
+  specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[];
   source: StringLiteral | null;
-  assertions: Array<ImportAttribute> | null;
-  attributes: Array<ImportAttribute> | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
   exportKind: "type" | "value" | null;
 }
 
@@ -480,10 +480,10 @@ export interface ForOfStatement extends BaseNode {
 
 export interface ImportDeclaration extends BaseNode {
   type: "ImportDeclaration";
-  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[];
   source: StringLiteral;
-  assertions: Array<ImportAttribute> | null;
-  attributes: Array<ImportAttribute> | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
   importKind: "type" | "typeof" | "value" | null;
   module: boolean | null;
   phase: "source" | "defer" | null;
@@ -523,7 +523,7 @@ export interface ClassMethod extends BaseNode {
   type: "ClassMethod";
   kind: "get" | "set" | "method" | "constructor";
   key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
-  params: Array<FunctionParameter | TSParameterProperty>;
+  params: (FunctionParameter | TSParameterProperty)[];
   body: BlockStatement;
   computed: boolean;
   static: boolean;
@@ -532,7 +532,7 @@ export interface ClassMethod extends BaseNode {
   abstract: boolean | null;
   access: "public" | "private" | "protected" | null;
   accessibility: "public" | "private" | "protected" | null;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   optional: boolean | null;
   override: boolean;
   returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
@@ -541,8 +541,8 @@ export interface ClassMethod extends BaseNode {
 
 export interface ObjectPattern extends BaseNode {
   type: "ObjectPattern";
-  properties: Array<RestElement | ObjectProperty>;
-  decorators: Array<Decorator> | null;
+  properties: (RestElement | ObjectProperty)[];
+  decorators: Decorator[] | null;
   optional: boolean | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -571,8 +571,8 @@ export interface TemplateElement extends BaseNode {
 
 export interface TemplateLiteral extends BaseNode {
   type: "TemplateLiteral";
-  quasis: Array<TemplateElement>;
-  expressions: Array<Expression | TSType>;
+  quasis: TemplateElement[];
+  expressions: (Expression | TSType)[];
 }
 
 export interface YieldExpression extends BaseNode {
@@ -611,7 +611,7 @@ export interface OptionalMemberExpression extends BaseNode {
 export interface OptionalCallExpression extends BaseNode {
   type: "OptionalCallExpression";
   callee: Expression;
-  arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>;
+  arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
   optional: boolean;
   typeArguments: TypeParameterInstantiation | null;
   typeParameters: TSTypeParameterInstantiation | null;
@@ -622,7 +622,7 @@ export interface ClassProperty extends BaseNode {
   key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
   value: Expression | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   computed: boolean;
   static: boolean;
   abstract: boolean | null;
@@ -640,7 +640,7 @@ export interface ClassAccessorProperty extends BaseNode {
   key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName;
   value: Expression | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   computed: boolean;
   static: boolean;
   abstract: boolean | null;
@@ -657,7 +657,7 @@ export interface ClassPrivateProperty extends BaseNode {
   type: "ClassPrivateProperty";
   key: PrivateName;
   value: Expression | null;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   static: boolean;
   definite: boolean | null;
   optional: boolean | null;
@@ -670,7 +670,7 @@ export interface ClassPrivateMethod extends BaseNode {
   type: "ClassPrivateMethod";
   kind: "get" | "set" | "method";
   key: PrivateName;
-  params: Array<FunctionParameter | TSParameterProperty>;
+  params: (FunctionParameter | TSParameterProperty)[];
   body: BlockStatement;
   static: boolean;
   abstract: boolean | null;
@@ -678,7 +678,7 @@ export interface ClassPrivateMethod extends BaseNode {
   accessibility: "public" | "private" | "protected" | null;
   async: boolean;
   computed: boolean;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   generator: boolean;
   optional: boolean | null;
   override: boolean;
@@ -693,7 +693,7 @@ export interface PrivateName extends BaseNode {
 
 export interface StaticBlock extends BaseNode {
   type: "StaticBlock";
-  body: Array<Statement>;
+  body: Statement[];
 }
 
 export interface ImportAttribute extends BaseNode {
@@ -734,10 +734,10 @@ export interface DeclareClass extends BaseNode {
   type: "DeclareClass";
   id: Identifier;
   typeParameters: TypeParameterDeclaration | null;
-  extends: Array<InterfaceExtends> | null;
+  extends: InterfaceExtends[] | null;
   body: ObjectTypeAnnotation;
-  implements: Array<ClassImplements> | null;
-  mixins: Array<InterfaceExtends> | null;
+  implements: ClassImplements[] | null;
+  mixins: InterfaceExtends[] | null;
 }
 
 export interface DeclareFunction extends BaseNode {
@@ -750,7 +750,7 @@ export interface DeclareInterface extends BaseNode {
   type: "DeclareInterface";
   id: Identifier;
   typeParameters: TypeParameterDeclaration | null;
-  extends: Array<InterfaceExtends> | null;
+  extends: InterfaceExtends[] | null;
   body: ObjectTypeAnnotation;
 }
 
@@ -789,18 +789,18 @@ export interface DeclareVariable extends BaseNode {
 export interface DeclareExportDeclaration extends BaseNode {
   type: "DeclareExportDeclaration";
   declaration: Flow | null;
-  specifiers: Array<ExportSpecifier | ExportNamespaceSpecifier> | null;
+  specifiers: (ExportSpecifier | ExportNamespaceSpecifier)[] | null;
   source: StringLiteral | null;
-  attributes: Array<ImportAttribute> | null;
-  assertions: Array<ImportAttribute> | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
   default: boolean | null;
 }
 
 export interface DeclareExportAllDeclaration extends BaseNode {
   type: "DeclareExportAllDeclaration";
   source: StringLiteral;
-  attributes: Array<ImportAttribute> | null;
-  assertions: Array<ImportAttribute> | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
   exportKind: "type" | "value" | null;
 }
 
@@ -816,7 +816,7 @@ export interface ExistsTypeAnnotation extends BaseNode {
 export interface FunctionTypeAnnotation extends BaseNode {
   type: "FunctionTypeAnnotation";
   typeParameters: TypeParameterDeclaration | null;
-  params: Array<FunctionTypeParam>;
+  params: FunctionTypeParam[];
   rest: FunctionTypeParam | null;
   returnType: FlowType;
   this: FunctionTypeParam | null;
@@ -849,19 +849,19 @@ export interface InterfaceDeclaration extends BaseNode {
   type: "InterfaceDeclaration";
   id: Identifier;
   typeParameters: TypeParameterDeclaration | null;
-  extends: Array<InterfaceExtends> | null;
+  extends: InterfaceExtends[] | null;
   body: ObjectTypeAnnotation;
 }
 
 export interface InterfaceTypeAnnotation extends BaseNode {
   type: "InterfaceTypeAnnotation";
-  extends: Array<InterfaceExtends> | null;
+  extends: InterfaceExtends[] | null;
   body: ObjectTypeAnnotation;
 }
 
 export interface IntersectionTypeAnnotation extends BaseNode {
   type: "IntersectionTypeAnnotation";
-  types: Array<FlowType>;
+  types: FlowType[];
 }
 
 export interface MixedTypeAnnotation extends BaseNode {
@@ -888,10 +888,10 @@ export interface NumberTypeAnnotation extends BaseNode {
 
 export interface ObjectTypeAnnotation extends BaseNode {
   type: "ObjectTypeAnnotation";
-  properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>;
-  indexers: Array<ObjectTypeIndexer>;
-  callProperties: Array<ObjectTypeCallProperty>;
-  internalSlots: Array<ObjectTypeInternalSlot>;
+  properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[];
+  indexers: ObjectTypeIndexer[];
+  callProperties: ObjectTypeCallProperty[];
+  internalSlots: ObjectTypeInternalSlot[];
   exact: boolean;
   inexact: boolean | null;
 }
@@ -970,7 +970,7 @@ export interface ThisTypeAnnotation extends BaseNode {
 
 export interface TupleTypeAnnotation extends BaseNode {
   type: "TupleTypeAnnotation";
-  types: Array<FlowType>;
+  types: FlowType[];
 }
 
 export interface TypeofTypeAnnotation extends BaseNode {
@@ -1006,17 +1006,17 @@ export interface TypeParameter extends BaseNode {
 
 export interface TypeParameterDeclaration extends BaseNode {
   type: "TypeParameterDeclaration";
-  params: Array<TypeParameter>;
+  params: TypeParameter[];
 }
 
 export interface TypeParameterInstantiation extends BaseNode {
   type: "TypeParameterInstantiation";
-  params: Array<FlowType>;
+  params: FlowType[];
 }
 
 export interface UnionTypeAnnotation extends BaseNode {
   type: "UnionTypeAnnotation";
-  types: Array<FlowType>;
+  types: FlowType[];
 }
 
 export interface Variance extends BaseNode {
@@ -1036,28 +1036,28 @@ export interface EnumDeclaration extends BaseNode {
 
 export interface EnumBooleanBody extends BaseNode {
   type: "EnumBooleanBody";
-  members: Array<EnumBooleanMember>;
+  members: EnumBooleanMember[];
   explicitType: boolean;
   hasUnknownMembers: boolean;
 }
 
 export interface EnumNumberBody extends BaseNode {
   type: "EnumNumberBody";
-  members: Array<EnumNumberMember>;
+  members: EnumNumberMember[];
   explicitType: boolean;
   hasUnknownMembers: boolean;
 }
 
 export interface EnumStringBody extends BaseNode {
   type: "EnumStringBody";
-  members: Array<EnumStringMember | EnumDefaultedMember>;
+  members: (EnumStringMember | EnumDefaultedMember)[];
   explicitType: boolean;
   hasUnknownMembers: boolean;
 }
 
 export interface EnumSymbolBody extends BaseNode {
   type: "EnumSymbolBody";
-  members: Array<EnumDefaultedMember>;
+  members: EnumDefaultedMember[];
   hasUnknownMembers: boolean;
 }
 
@@ -1112,7 +1112,7 @@ export interface JSXElement extends BaseNode {
   type: "JSXElement";
   openingElement: JSXOpeningElement;
   closingElement: JSXClosingElement | null;
-  children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+  children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
   selfClosing: boolean | null;
 }
 
@@ -1150,7 +1150,7 @@ export interface JSXNamespacedName extends BaseNode {
 export interface JSXOpeningElement extends BaseNode {
   type: "JSXOpeningElement";
   name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
-  attributes: Array<JSXAttribute | JSXSpreadAttribute>;
+  attributes: (JSXAttribute | JSXSpreadAttribute)[];
   selfClosing: boolean;
   typeArguments: TypeParameterInstantiation | null;
   typeParameters: TSTypeParameterInstantiation | null;
@@ -1170,7 +1170,7 @@ export interface JSXFragment extends BaseNode {
   type: "JSXFragment";
   openingFragment: JSXOpeningFragment;
   closingFragment: JSXClosingFragment;
-  children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+  children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
 }
 
 export interface JSXOpeningFragment extends BaseNode {
@@ -1189,7 +1189,7 @@ export interface Placeholder extends BaseNode {
   type: "Placeholder";
   expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern";
   name: Identifier;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   optional: boolean | null;
   typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -1227,12 +1227,12 @@ export interface ExportDefaultSpecifier extends BaseNode {
 
 export interface RecordExpression extends BaseNode {
   type: "RecordExpression";
-  properties: Array<ObjectProperty | SpreadElement>;
+  properties: (ObjectProperty | SpreadElement)[];
 }
 
 export interface TupleExpression extends BaseNode {
   type: "TupleExpression";
-  elements: Array<Expression | SpreadElement>;
+  elements: (Expression | SpreadElement)[];
 }
 
 export interface DecimalLiteral extends BaseNode {
@@ -1271,7 +1271,7 @@ export interface TSParameterProperty extends BaseNode {
   type: "TSParameterProperty";
   parameter: Identifier | AssignmentPattern;
   accessibility: "public" | "private" | "protected" | null;
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   override: boolean | null;
   readonly: boolean | null;
 }
@@ -1280,7 +1280,7 @@ export interface TSDeclareFunction extends BaseNode {
   type: "TSDeclareFunction";
   id: Identifier | null;
   typeParameters: TSTypeParameterDeclaration | Noop | null;
-  params: Array<FunctionParameter>;
+  params: FunctionParameter[];
   returnType: TSTypeAnnotation | Noop | null;
   async: boolean;
   declare: boolean | null;
@@ -1289,10 +1289,10 @@ export interface TSDeclareFunction extends BaseNode {
 
 export interface TSDeclareMethod extends BaseNode {
   type: "TSDeclareMethod";
-  decorators: Array<Decorator> | null;
+  decorators: Decorator[] | null;
   key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
   typeParameters: TSTypeParameterDeclaration | Noop | null;
-  params: Array<FunctionParameter | TSParameterProperty>;
+  params: (FunctionParameter | TSParameterProperty)[];
   returnType: TSTypeAnnotation | Noop | null;
   abstract: boolean | null;
   access: "public" | "private" | "protected" | null;
@@ -1315,14 +1315,14 @@ export interface TSQualifiedName extends BaseNode {
 export interface TSCallSignatureDeclaration extends BaseNode {
   type: "TSCallSignatureDeclaration";
   typeParameters: TSTypeParameterDeclaration | null;
-  parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
   typeAnnotation: TSTypeAnnotation | null;
 }
 
 export interface TSConstructSignatureDeclaration extends BaseNode {
   type: "TSConstructSignatureDeclaration";
   typeParameters: TSTypeParameterDeclaration | null;
-  parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
   typeAnnotation: TSTypeAnnotation | null;
 }
 
@@ -1340,7 +1340,7 @@ export interface TSMethodSignature extends BaseNode {
   type: "TSMethodSignature";
   key: Expression;
   typeParameters: TSTypeParameterDeclaration | null;
-  parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
   typeAnnotation: TSTypeAnnotation | null;
   computed: boolean;
   kind: "method" | "get" | "set";
@@ -1349,7 +1349,7 @@ export interface TSMethodSignature extends BaseNode {
 
 export interface TSIndexSignature extends BaseNode {
   type: "TSIndexSignature";
-  parameters: Array<Identifier>;
+  parameters: Identifier[];
   typeAnnotation: TSTypeAnnotation | null;
   readonly: boolean | null;
   static: boolean | null;
@@ -1414,14 +1414,14 @@ export interface TSThisType extends BaseNode {
 export interface TSFunctionType extends BaseNode {
   type: "TSFunctionType";
   typeParameters: TSTypeParameterDeclaration | null;
-  parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
   typeAnnotation: TSTypeAnnotation | null;
 }
 
 export interface TSConstructorType extends BaseNode {
   type: "TSConstructorType";
   typeParameters: TSTypeParameterDeclaration | null;
-  parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
   typeAnnotation: TSTypeAnnotation | null;
   abstract: boolean | null;
 }
@@ -1447,7 +1447,7 @@ export interface TSTypeQuery extends BaseNode {
 
 export interface TSTypeLiteral extends BaseNode {
   type: "TSTypeLiteral";
-  members: Array<TSTypeElement>;
+  members: TSTypeElement[];
 }
 
 export interface TSArrayType extends BaseNode {
@@ -1457,7 +1457,7 @@ export interface TSArrayType extends BaseNode {
 
 export interface TSTupleType extends BaseNode {
   type: "TSTupleType";
-  elementTypes: Array<TSType | TSNamedTupleMember>;
+  elementTypes: (TSType | TSNamedTupleMember)[];
 }
 
 export interface TSOptionalType extends BaseNode {
@@ -1479,12 +1479,12 @@ export interface TSNamedTupleMember extends BaseNode {
 
 export interface TSUnionType extends BaseNode {
   type: "TSUnionType";
-  types: Array<TSType>;
+  types: TSType[];
 }
 
 export interface TSIntersectionType extends BaseNode {
   type: "TSIntersectionType";
-  types: Array<TSType>;
+  types: TSType[];
 }
 
 export interface TSConditionalType extends BaseNode {
@@ -1528,8 +1528,8 @@ export interface TSMappedType extends BaseNode {
 
 export interface TSTemplateLiteralType extends BaseNode {
   type: "TSTemplateLiteralType";
-  quasis: Array<TemplateElement>;
-  types: Array<TSType>;
+  quasis: TemplateElement[];
+  types: TSType[];
 }
 
 export interface TSLiteralType extends BaseNode {
@@ -1547,14 +1547,14 @@ export interface TSInterfaceDeclaration extends BaseNode {
   type: "TSInterfaceDeclaration";
   id: Identifier;
   typeParameters: TSTypeParameterDeclaration | null;
-  extends: Array<TSExpressionWithTypeArguments> | null;
+  extends: TSExpressionWithTypeArguments[] | null;
   body: TSInterfaceBody;
   declare: boolean | null;
 }
 
 export interface TSInterfaceBody extends BaseNode {
   type: "TSInterfaceBody";
-  body: Array<TSTypeElement>;
+  body: TSTypeElement[];
 }
 
 export interface TSTypeAliasDeclaration extends BaseNode {
@@ -1591,13 +1591,13 @@ export interface TSTypeAssertion extends BaseNode {
 
 export interface TSEnumBody extends BaseNode {
   type: "TSEnumBody";
-  members: Array<TSEnumMember>;
+  members: TSEnumMember[];
 }
 
 export interface TSEnumDeclaration extends BaseNode {
   type: "TSEnumDeclaration";
   id: Identifier;
-  members: Array<TSEnumMember>;
+  members: TSEnumMember[];
   body: TSEnumBody | null;
   const: boolean | null;
   declare: boolean | null;
@@ -1621,7 +1621,7 @@ export interface TSModuleDeclaration extends BaseNode {
 
 export interface TSModuleBlock extends BaseNode {
   type: "TSModuleBlock";
-  body: Array<Statement>;
+  body: Statement[];
 }
 
 export interface TSImportType extends BaseNode {
@@ -1667,12 +1667,12 @@ export interface TSTypeAnnotation extends BaseNode {
 
 export interface TSTypeParameterInstantiation extends BaseNode {
   type: "TSTypeParameterInstantiation";
-  params: Array<TSType>;
+  params: TSType[];
 }
 
 export interface TSTypeParameterDeclaration extends BaseNode {
   type: "TSTypeParameterDeclaration";
-  params: Array<TSTypeParameter>;
+  params: TSTypeParameter[];
 }
 
 export interface TSTypeParameter extends BaseNode {
@@ -1811,15 +1811,15 @@ export interface Aliases {
   ModuleDeclaration: ModuleDeclaration;
 }
 
-export function arrayExpression(elements?: Array<null | Expression | SpreadElement>): ArrayExpression;
+export function arrayExpression(elements?: (null | Expression | SpreadElement)[]): ArrayExpression;
 export function assignmentExpression(operator: string, left: LVal | OptionalMemberExpression, right: Expression): AssignmentExpression;
 export function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: Expression | PrivateName, right: Expression): BinaryExpression;
 export function interpreterDirective(value: string): InterpreterDirective;
 export function directive(value: DirectiveLiteral): Directive;
 export function directiveLiteral(value: string): DirectiveLiteral;
-export function blockStatement(body: Array<Statement>, directives?: Array<Directive>): BlockStatement;
+export function blockStatement(body: Statement[], directives?: Directive[]): BlockStatement;
 export function breakStatement(label?: Identifier | null): BreakStatement;
-export function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>): CallExpression;
+export function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): CallExpression;
 export function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause;
 export function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression;
 export function continueStatement(label?: Identifier | null): ContinueStatement;
@@ -1827,11 +1827,11 @@ export function debuggerStatement(): DebuggerStatement;
 export function doWhileStatement(test: Expression, body: Statement): DoWhileStatement;
 export function emptyStatement(): EmptyStatement;
 export function expressionStatement(expression: Expression): ExpressionStatement;
-export function file(program: Program, comments?: Array<CommentBlock | CommentLine> | null, tokens?: Array<any> | null): File;
+export function file(program: Program, comments?: (CommentBlock | CommentLine)[] | null, tokens?: any[] | null): File;
 export function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement;
 export function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement;
-export function functionDeclaration(id: Identifier | null | undefined, params: Array<FunctionParameter>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
-export function functionExpression(id: Identifier | null | undefined, params: Array<FunctionParameter>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
+export function functionDeclaration(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
+export function functionExpression(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
 export function identifier(name: string): Identifier;
 export function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement;
 export function labeledStatement(label: Identifier, body: Statement): LabeledStatement;
@@ -1842,51 +1842,51 @@ export function booleanLiteral(value: boolean): BooleanLiteral;
 export function regExpLiteral(pattern: string, flags?: string): RegExpLiteral;
 export function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression;
 export function memberExpression(object: Expression | Super, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: boolean | null): MemberExpression;
-export function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>): NewExpression;
-export function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
-export function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;
-export function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: Array<FunctionParameter>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
-export function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;
+export function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): NewExpression;
+export function program(body: Statement[], directives?: Directive[], sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
+export function objectExpression(properties: (ObjectMethod | ObjectProperty | SpreadElement)[]): ObjectExpression;
+export function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: FunctionParameter[], body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
+export function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Decorator[] | null): ObjectProperty;
 export function restElement(argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern): RestElement;
 export function returnStatement(argument?: Expression | null): ReturnStatement;
-export function sequenceExpression(expressions: Array<Expression>): SequenceExpression;
+export function sequenceExpression(expressions: Expression[]): SequenceExpression;
 export function parenthesizedExpression(expression: Expression): ParenthesizedExpression;
-export function switchCase(test: Expression | null | undefined, consequent: Array<Statement>): SwitchCase;
-export function switchStatement(discriminant: Expression, cases: Array<SwitchCase>): SwitchStatement;
+export function switchCase(test: Expression | null | undefined, consequent: Statement[]): SwitchCase;
+export function switchStatement(discriminant: Expression, cases: SwitchCase[]): SwitchStatement;
 export function thisExpression(): ThisExpression;
 export function throwStatement(argument: Expression): ThrowStatement;
 export function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement;
 export function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression;
 export function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression;
-export function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: Array<VariableDeclarator>): VariableDeclaration;
+export function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: VariableDeclarator[]): VariableDeclaration;
 export function variableDeclarator(id: LVal | VoidPattern, init?: Expression | null): VariableDeclarator;
 export function whileStatement(test: Expression, body: Statement): WhileStatement;
 export function withStatement(object: Expression, body: Statement): WithStatement;
 export function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression, right: Expression): AssignmentPattern;
-export function arrayPattern(elements: Array<null | PatternLike>): ArrayPattern;
-export function arrowFunctionExpression(params: Array<FunctionParameter>, body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
-export function classBody(body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>): ClassBody;
-export function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassExpression;
-export function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassDeclaration;
-export function exportAllDeclaration(source: StringLiteral): ExportAllDeclaration;
+export function arrayPattern(elements: (null | PatternLike)[]): ArrayPattern;
+export function arrowFunctionExpression(params: FunctionParameter[], body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
+export function classBody(body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]): ClassBody;
+export function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassExpression;
+export function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassDeclaration;
+export function exportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): ExportAllDeclaration;
 export function exportDefaultDeclaration(declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration;
-export function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>, source?: StringLiteral | null): ExportNamedDeclaration;
+export function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[], source?: StringLiteral | null, attributes?: ImportAttribute[] | null): ExportNamedDeclaration;
 export function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier;
 export function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement;
-export function importDeclaration(specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source: StringLiteral): ImportDeclaration;
+export function importDeclaration(specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], source: StringLiteral, attributes?: ImportAttribute[] | null): ImportDeclaration;
 export function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier;
 export function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
 export function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;
 export function importExpression(source: Expression, options?: Expression | null): ImportExpression;
 export function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
-export function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: Array<FunctionParameter | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
-export function objectPattern(properties: Array<RestElement | ObjectProperty>): ObjectPattern;
+export function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
+export function objectPattern(properties: (RestElement | ObjectProperty)[]): ObjectPattern;
 export function spreadElement(argument: Expression): SpreadElement;
 declare function _super(): Super;
 export { _super as super}
 export function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression;
 export function templateElement(value: { raw: string, cooked?: string }, tail?: boolean): TemplateElement;
-export function templateLiteral(quasis: Array<TemplateElement>, expressions: Array<Expression | TSType>): TemplateLiteral;
+export function templateLiteral(quasis: TemplateElement[], expressions: (Expression | TSType)[]): TemplateLiteral;
 export function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression;
 export function awaitExpression(argument: Expression): AwaitExpression;
 declare function _import(): Import;
@@ -1894,13 +1894,13 @@ export { _import as import}
 export function bigIntLiteral(value: string): BigIntLiteral;
 export function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
 export function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
-export function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>, optional: boolean): OptionalCallExpression;
-export function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
-export function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
-export function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Array<Decorator> | null, _static?: boolean): ClassPrivateProperty;
-export function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: Array<FunctionParameter | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
+export function optionalCallExpression(callee: Expression, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[], optional: boolean): OptionalCallExpression;
+export function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassProperty;
+export function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
+export function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Decorator[] | null, _static?: boolean): ClassPrivateProperty;
+export function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, _static?: boolean): ClassPrivateMethod;
 export function privateName(id: Identifier): PrivateName;
-export function staticBlock(body: Array<Statement>): StaticBlock;
+export function staticBlock(body: Statement[]): StaticBlock;
 export function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute;
 export function anyTypeAnnotation(): AnyTypeAnnotation;
 export function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation;
@@ -1908,32 +1908,32 @@ export function booleanTypeAnnotation(): BooleanTypeAnnotation;
 export function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation;
 export function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
 export function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements;
-export function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareClass;
+export function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareClass;
 export function declareFunction(id: Identifier): DeclareFunction;
-export function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;
+export function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;
 export function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule;
 export function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports;
 export function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias;
 export function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType;
 export function declareVariable(id: Identifier): DeclareVariable;
-export function declareExportDeclaration(declaration?: Flow | null, specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null, source?: StringLiteral | null, attributes?: Array<ImportAttribute> | null): DeclareExportDeclaration;
-export function declareExportAllDeclaration(source: StringLiteral, attributes?: Array<ImportAttribute> | null): DeclareExportAllDeclaration;
+export function declareExportDeclaration(declaration?: Flow | null, specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null, source?: StringLiteral | null, attributes?: ImportAttribute[] | null): DeclareExportDeclaration;
+export function declareExportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): DeclareExportAllDeclaration;
 export function declaredPredicate(value: Flow): DeclaredPredicate;
 export function existsTypeAnnotation(): ExistsTypeAnnotation;
-export function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: Array<FunctionTypeParam>, rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
+export function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: FunctionTypeParam[], rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
 export function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam;
 export function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation;
 export function inferredPredicate(): InferredPredicate;
 export function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends;
-export function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;
-export function interfaceTypeAnnotation(_extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;
-export function intersectionTypeAnnotation(types: Array<FlowType>): IntersectionTypeAnnotation;
+export function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;
+export function interfaceTypeAnnotation(_extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;
+export function intersectionTypeAnnotation(types: FlowType[]): IntersectionTypeAnnotation;
 export function mixedTypeAnnotation(): MixedTypeAnnotation;
 export function emptyTypeAnnotation(): EmptyTypeAnnotation;
 export function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation;
 export function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation;
 export function numberTypeAnnotation(): NumberTypeAnnotation;
-export function objectTypeAnnotation(properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>, indexers?: Array<ObjectTypeIndexer>, callProperties?: Array<ObjectTypeCallProperty>, internalSlots?: Array<ObjectTypeInternalSlot>, exact?: boolean): ObjectTypeAnnotation;
+export function objectTypeAnnotation(properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[], internalSlots?: ObjectTypeInternalSlot[], exact?: boolean): ObjectTypeAnnotation;
 export function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot;
 export function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty;
 export function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer;
@@ -1945,22 +1945,22 @@ export function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnn
 export function stringTypeAnnotation(): StringTypeAnnotation;
 export function symbolTypeAnnotation(): SymbolTypeAnnotation;
 export function thisTypeAnnotation(): ThisTypeAnnotation;
-export function tupleTypeAnnotation(types: Array<FlowType>): TupleTypeAnnotation;
+export function tupleTypeAnnotation(types: FlowType[]): TupleTypeAnnotation;
 export function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation;
 export function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias;
 export function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation;
 export function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression;
 export function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter;
-export function typeParameterDeclaration(params: Array<TypeParameter>): TypeParameterDeclaration;
-export function typeParameterInstantiation(params: Array<FlowType>): TypeParameterInstantiation;
-export function unionTypeAnnotation(types: Array<FlowType>): UnionTypeAnnotation;
+export function typeParameterDeclaration(params: TypeParameter[]): TypeParameterDeclaration;
+export function typeParameterInstantiation(params: FlowType[]): TypeParameterInstantiation;
+export function unionTypeAnnotation(types: FlowType[]): UnionTypeAnnotation;
 export function variance(kind: "minus" | "plus"): Variance;
 export function voidTypeAnnotation(): VoidTypeAnnotation;
 export function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration;
-export function enumBooleanBody(members: Array<EnumBooleanMember>): EnumBooleanBody;
-export function enumNumberBody(members: Array<EnumNumberMember>): EnumNumberBody;
-export function enumStringBody(members: Array<EnumStringMember | EnumDefaultedMember>): EnumStringBody;
-export function enumSymbolBody(members: Array<EnumDefaultedMember>): EnumSymbolBody;
+export function enumBooleanBody(members: EnumBooleanMember[]): EnumBooleanBody;
+export function enumNumberBody(members: EnumNumberMember[]): EnumNumberBody;
+export function enumStringBody(members: (EnumStringMember | EnumDefaultedMember)[]): EnumStringBody;
+export function enumSymbolBody(members: EnumDefaultedMember[]): EnumSymbolBody;
 export function enumBooleanMember(id: Identifier): EnumBooleanMember;
 export function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember;
 export function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember;
@@ -1969,17 +1969,17 @@ export function indexedAccessType(objectType: FlowType, indexType: FlowType): In
 export function optionalIndexedAccessType(objectType: FlowType, indexType: FlowType): OptionalIndexedAccessType;
 export function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute;
 export function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement;
-export function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>, selfClosing?: boolean | null): JSXElement;
+export function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[], selfClosing?: boolean | null): JSXElement;
 export function jsxEmptyExpression(): JSXEmptyExpression;
 export function jsxExpressionContainer(expression: Expression | JSXEmptyExpression): JSXExpressionContainer;
 export function jsxSpreadChild(expression: Expression): JSXSpreadChild;
 export function jsxIdentifier(name: string): JSXIdentifier;
 export function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression;
 export function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName;
-export function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: Array<JSXAttribute | JSXSpreadAttribute>, selfClosing?: boolean): JSXOpeningElement;
+export function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: (JSXAttribute | JSXSpreadAttribute)[], selfClosing?: boolean): JSXOpeningElement;
 export function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute;
 export function jsxText(value: string): JSXText;
-export function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>): JSXFragment;
+export function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]): JSXFragment;
 export function jsxOpeningFragment(): JSXOpeningFragment;
 export function jsxClosingFragment(): JSXClosingFragment;
 export function noop(): Noop;
@@ -1990,8 +1990,8 @@ export function bindExpression(object: Expression, callee: Expression): BindExpr
 export function decorator(expression: Expression): Decorator;
 export function doExpression(body: BlockStatement, async?: boolean): DoExpression;
 export function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier;
-export function recordExpression(properties: Array<ObjectProperty | SpreadElement>): RecordExpression;
-export function tupleExpression(elements?: Array<Expression | SpreadElement>): TupleExpression;
+export function recordExpression(properties: (ObjectProperty | SpreadElement)[]): RecordExpression;
+export function tupleExpression(elements?: (Expression | SpreadElement)[]): TupleExpression;
 export function decimalLiteral(value: string): DecimalLiteral;
 export function moduleExpression(body: Program): ModuleExpression;
 export function topicReference(): TopicReference;
@@ -2000,14 +2000,14 @@ export function pipelineBareFunction(callee: Expression): PipelineBareFunction;
 export function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference;
 export function voidPattern(): VoidPattern;
 export function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;
-export function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<FunctionParameter>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
-export function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<FunctionParameter | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
+export function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: FunctionParameter[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
+export function tsDeclareMethod(decorators: Decorator[] | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: (FunctionParameter | TSParameterProperty)[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
 export function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
-export function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
-export function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
+export function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
+export function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
 export function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null): TSPropertySignature;
-export function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;
-export function tsIndexSignature(parameters: Array<Identifier>, typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;
+export function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;
+export function tsIndexSignature(parameters: Identifier[], typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;
 export function tsAnyKeyword(): TSAnyKeyword;
 export function tsBooleanKeyword(): TSBooleanKeyword;
 export function tsBigIntKeyword(): TSBigIntKeyword;
@@ -2022,40 +2022,40 @@ export function tsUndefinedKeyword(): TSUndefinedKeyword;
 export function tsUnknownKeyword(): TSUnknownKeyword;
 export function tsVoidKeyword(): TSVoidKeyword;
 export function tsThisType(): TSThisType;
-export function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;
-export function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;
+export function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;
+export function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;
 export function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference;
 export function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation?: TSTypeAnnotation | null, asserts?: boolean | null): TSTypePredicate;
 export function tsTypeQuery(exprName: TSEntityName | TSImportType, typeParameters?: TSTypeParameterInstantiation | null): TSTypeQuery;
-export function tsTypeLiteral(members: Array<TSTypeElement>): TSTypeLiteral;
+export function tsTypeLiteral(members: TSTypeElement[]): TSTypeLiteral;
 export function tsArrayType(elementType: TSType): TSArrayType;
-export function tsTupleType(elementTypes: Array<TSType | TSNamedTupleMember>): TSTupleType;
+export function tsTupleType(elementTypes: (TSType | TSNamedTupleMember)[]): TSTupleType;
 export function tsOptionalType(typeAnnotation: TSType): TSOptionalType;
 export function tsRestType(typeAnnotation: TSType): TSRestType;
 export function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember;
-export function tsUnionType(types: Array<TSType>): TSUnionType;
-export function tsIntersectionType(types: Array<TSType>): TSIntersectionType;
+export function tsUnionType(types: TSType[]): TSUnionType;
+export function tsIntersectionType(types: TSType[]): TSIntersectionType;
 export function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType;
 export function tsInferType(typeParameter: TSTypeParameter): TSInferType;
 export function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;
 export function tsTypeOperator(typeAnnotation: TSType, operator?: string): TSTypeOperator;
 export function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;
 export function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType;
-export function tsTemplateLiteralType(quasis: Array<TemplateElement>, types: Array<TSType>): TSTemplateLiteralType;
+export function tsTemplateLiteralType(quasis: TemplateElement[], types: TSType[]): TSTemplateLiteralType;
 export function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression): TSLiteralType;
 export function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments;
-export function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: Array<TSExpressionWithTypeArguments> | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;
-export function tsInterfaceBody(body: Array<TSTypeElement>): TSInterfaceBody;
+export function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: TSExpressionWithTypeArguments[] | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;
+export function tsInterfaceBody(body: TSTypeElement[]): TSInterfaceBody;
 export function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration;
 export function tsInstantiationExpression(expression: Expression, typeParameters?: TSTypeParameterInstantiation | null): TSInstantiationExpression;
 export function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression;
 export function tsSatisfiesExpression(expression: Expression, typeAnnotation: TSType): TSSatisfiesExpression;
 export function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;
-export function tsEnumBody(members: Array<TSEnumMember>): TSEnumBody;
-export function tsEnumDeclaration(id: Identifier, members: Array<TSEnumMember>): TSEnumDeclaration;
+export function tsEnumBody(members: TSEnumMember[]): TSEnumBody;
+export function tsEnumDeclaration(id: Identifier, members: TSEnumMember[]): TSEnumDeclaration;
 export function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember;
 export function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration;
-export function tsModuleBlock(body: Array<Statement>): TSModuleBlock;
+export function tsModuleBlock(body: Statement[]): TSModuleBlock;
 export function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType;
 export function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration;
 export function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference;
@@ -2063,8 +2063,8 @@ export function tsNonNullExpression(expression: Expression): TSNonNullExpression
 export function tsExportAssignment(expression: Expression): TSExportAssignment;
 export function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration;
 export function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;
-export function tsTypeParameterInstantiation(params: Array<TSType>): TSTypeParameterInstantiation;
-export function tsTypeParameterDeclaration(params: Array<TSTypeParameter>): TSTypeParameterDeclaration;
+export function tsTypeParameterInstantiation(params: TSType[]): TSTypeParameterInstantiation;
+export function tsTypeParameterDeclaration(params: TSTypeParameter[]): TSTypeParameterDeclaration;
 export function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter;
 export function isAccessor(node: object | null | undefined, opts?: object | null): node is Accessor;
 export function assertAccessor(node: object | null | undefined, opts?: object | null): void;