@openrewrite/rewrite 0.21.0 → 0.22.1

package/dist/src/javascript/tree/tree.d.ts

@@ -1,7 +1,7 @@
 import { JS } from "./support_types";
 import { JavaScriptVisitor } from "../visitor";
 import { Checksum, Cursor, FileAttributes, Markers, PrintOutputCapture, SourceFile, Tree, TreeVisitor, UUID } from "../../core";
-import { Expression, J, JavaSourceFile, JavaType, JContainer, JLeftPadded, JRightPadded, NameTree, Space, Statement, TypedTree, TypeTree } from "../../java/tree";
+import { Expression, J, JavaSourceFile, JavaType, JContainer, JLeftPadded, JRightPadded, NameTree, Space, Statement, TypedTree, TypeTree, MethodCall, Loop } from "../../java/tree";
 import * as Java from "../../java/tree";
 declare const CompilationUnit_base: ((abstract new (...args: any[]) => {
     readonly sourcePath: string;
@@ -166,7 +166,7 @@ declare const ArrowFunction_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class ArrowFunction extends ArrowFunction_base implements Statement, Expression, TypedTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], parameters: Java.Lambda.Parameters, returnTypeExpression: TypeTree | null, arrow: Space, body: J, _type: JavaType | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], typeParameters: Java.TypeParameters | null, parameters: Java.Lambda.Parameters, returnTypeExpression: TypeTree | null, arrow: Space, body: J, _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): ArrowFunction;
@@ -182,6 +182,9 @@ export declare class ArrowFunction extends ArrowFunction_base implements Stateme
     private readonly _modifiers;
     get modifiers(): Java.Modifier[];
     withModifiers(modifiers: Java.Modifier[]): ArrowFunction;
+    private readonly _typeParameters;
+    get typeParameters(): Java.TypeParameters | null;
+    withTypeParameters(typeParameters: Java.TypeParameters | null): ArrowFunction;
     private readonly _parameters;
     get parameters(): Java.Lambda.Parameters;
     withParameters(parameters: Java.Lambda.Parameters): ArrowFunction;
@@ -409,7 +412,7 @@ declare const FunctionType_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class FunctionType extends FunctionType_base implements Expression, TypeTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, parameters: JContainer<Statement>, arrow: Space, returnType: Expression, _type: JavaType | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, constructorType: JRightPadded<boolean>, parameters: JContainer<Statement>, arrow: Space, returnType: Expression, _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): FunctionType;
@@ -419,6 +422,9 @@ export declare class FunctionType extends FunctionType_base implements Expressio
     private readonly _markers;
     get markers(): Markers;
     withMarkers(markers: Markers): FunctionType;
+    private readonly _constructorType;
+    get constructorType(): boolean;
+    withConstructorType(constructorType: boolean): FunctionType;
     private readonly _parameters;
     get parameters(): Statement[];
     withParameters(parameters: Statement[]): FunctionType;
@@ -433,6 +439,8 @@ export declare class FunctionType extends FunctionType_base implements Expressio
     withType(_type: JavaType | null): FunctionType;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get padding(): {
+        readonly constructorType: JRightPadded<boolean>;
+        withConstructorType(constructorType: JRightPadded<boolean>): FunctionType;
         readonly parameters: JContainer<Statement>;
         withParameters(parameters: JContainer<Statement>): FunctionType;
     };
@@ -461,7 +469,7 @@ declare const JsImport_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class JsImport extends JsImport_base implements Statement {
-    constructor(id: UUID, prefix: Space, markers: Markers, name: JRightPadded<Java.Identifier> | null, imports: JContainer<Expression> | null, _from: Space | null, target: Java.Literal | null, initializer: JLeftPadded<Expression> | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, name: JRightPadded<Java.Identifier> | null, importType: JLeftPadded<boolean>, imports: JContainer<Expression> | null, _from: Space | null, target: Java.Literal | null, initializer: JLeftPadded<Expression> | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): JsImport;
@@ -474,6 +482,9 @@ export declare class JsImport extends JsImport_base implements Statement {
     private readonly _name;
     get name(): Java.Identifier | null;
     withName(name: Java.Identifier | null): JsImport;
+    private readonly _importType;
+    get importType(): boolean;
+    withImportType(importType: boolean): JsImport;
     private readonly _imports;
     get imports(): Expression[] | null;
     withImports(imports: Expression[] | null): JsImport;
@@ -490,12 +501,63 @@ export declare class JsImport extends JsImport_base implements Statement {
     get padding(): {
         readonly name: JRightPadded<Java.Identifier> | null;
         withName(name: JRightPadded<Java.Identifier> | null): JsImport;
+        readonly importType: JLeftPadded<boolean>;
+        withImportType(importType: JLeftPadded<boolean>): JsImport;
         readonly imports: JContainer<Expression> | null;
         withImports(imports: JContainer<Expression> | null): JsImport;
         readonly initializer: JLeftPadded<Expression> | null;
         withInitializer(initializer: JLeftPadded<Expression> | null): JsImport;
     };
 }
+declare const JsImportSpecifier_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JsImportSpecifier extends JsImportSpecifier_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, importType: JLeftPadded<boolean>, specifier: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JsImportSpecifier;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JsImportSpecifier;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JsImportSpecifier;
+    private readonly _importType;
+    get importType(): boolean;
+    withImportType(importType: boolean): JsImportSpecifier;
+    private readonly _specifier;
+    get specifier(): Expression;
+    withSpecifier(specifier: Expression): JsImportSpecifier;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): JsImportSpecifier;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly importType: JLeftPadded<boolean>;
+        withImportType(importType: JLeftPadded<boolean>): JsImportSpecifier;
+    };
+}
 declare const JsBinary_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -580,8 +642,8 @@ declare const ObjectBindingDeclarations_base: ((abstract new (...args: any[]) =>
     isJava: boolean;
     isJavaScript: boolean;
 }) & ObjectConstructor;
-export declare class ObjectBindingDeclarations extends ObjectBindingDeclarations_base implements Statement, TypedTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], typeExpression: TypeTree | null, bindings: JContainer<ObjectBindingDeclarations.Binding>, initializer: JLeftPadded<Expression> | null);
+export declare class ObjectBindingDeclarations extends ObjectBindingDeclarations_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], typeExpression: TypeTree | null, bindings: JContainer<BindingElement>, initializer: JLeftPadded<Expression> | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): ObjectBindingDeclarations;
@@ -601,8 +663,8 @@ export declare class ObjectBindingDeclarations extends ObjectBindingDeclarations
     get typeExpression(): TypeTree | null;
     withTypeExpression(typeExpression: TypeTree | null): ObjectBindingDeclarations;
     private readonly _bindings;
-    get bindings(): ObjectBindingDeclarations.Binding[];
-    withBindings(bindings: ObjectBindingDeclarations.Binding[]): ObjectBindingDeclarations;
+    get bindings(): BindingElement[];
+    withBindings(bindings: BindingElement[]): ObjectBindingDeclarations;
     private readonly _initializer;
     get initializer(): Expression | null;
     withInitializer(initializer: Expression | null): ObjectBindingDeclarations;
@@ -610,77 +672,12 @@ export declare class ObjectBindingDeclarations extends ObjectBindingDeclarations
     get type(): JavaType | null;
     withType(type: JavaType): ObjectBindingDeclarations;
     get padding(): {
-        readonly bindings: JContainer<ObjectBindingDeclarations.Binding>;
-        withBindings(bindings: JContainer<ObjectBindingDeclarations.Binding>): ObjectBindingDeclarations;
+        readonly bindings: JContainer<BindingElement>;
+        withBindings(bindings: JContainer<BindingElement>): ObjectBindingDeclarations;
         readonly initializer: JLeftPadded<Expression> | null;
         withInitializer(initializer: JLeftPadded<Expression> | null): ObjectBindingDeclarations;
     };
 }
-export declare namespace ObjectBindingDeclarations {
-    const Binding_base: ((abstract new (...args: any[]) => {
-        readonly prefix: Space;
-        withPrefix(prefix: Space): JS;
-        readonly id: Uint8Array;
-        withId(id: UUID): JS;
-        readonly markers: Markers;
-        withMarkers(markers: Markers): JS;
-        isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
-        accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
-        acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
-        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
-        constructor: Function;
-        toString(): string;
-        toLocaleString(): string;
-        valueOf(): Object;
-        hasOwnProperty(v: PropertyKey): boolean;
-        isPrototypeOf(v: Object): boolean;
-        propertyIsEnumerable(v: PropertyKey): boolean;
-    }) & {
-        isTree: boolean;
-        isJava: boolean;
-        isJavaScript: boolean;
-    }) & ObjectConstructor;
-    export class Binding extends Binding_base implements NameTree {
-        constructor(id: UUID, prefix: Space, markers: Markers, propertyName: JRightPadded<Java.Identifier> | null, name: Java.Identifier, dimensionsAfterName: JLeftPadded<Space>[], afterVararg: Space | null, initializer: JLeftPadded<Expression> | null, variableType: JavaType.Variable | null);
-        private readonly _id;
-        get id(): UUID;
-        withId(id: UUID): ObjectBindingDeclarations.Binding;
-        private readonly _prefix;
-        get prefix(): Space;
-        withPrefix(prefix: Space): ObjectBindingDeclarations.Binding;
-        private readonly _markers;
-        get markers(): Markers;
-        withMarkers(markers: Markers): ObjectBindingDeclarations.Binding;
-        private readonly _propertyName;
-        get propertyName(): Java.Identifier | null;
-        withPropertyName(propertyName: Java.Identifier | null): ObjectBindingDeclarations.Binding;
-        private readonly _name;
-        get name(): Java.Identifier;
-        withName(name: Java.Identifier): ObjectBindingDeclarations.Binding;
-        private readonly _dimensionsAfterName;
-        get dimensionsAfterName(): JLeftPadded<Space>[];
-        withDimensionsAfterName(dimensionsAfterName: JLeftPadded<Space>[]): ObjectBindingDeclarations.Binding;
-        private readonly _afterVararg;
-        get afterVararg(): Space | null;
-        withAfterVararg(afterVararg: Space | null): ObjectBindingDeclarations.Binding;
-        private readonly _initializer;
-        get initializer(): Expression | null;
-        withInitializer(initializer: Expression | null): ObjectBindingDeclarations.Binding;
-        private readonly _variableType;
-        get variableType(): JavaType.Variable | null;
-        withVariableType(variableType: JavaType.Variable | null): ObjectBindingDeclarations.Binding;
-        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
-        get type(): JavaType | null;
-        withType(type: JavaType): ObjectBindingDeclarations.Binding;
-        get padding(): {
-            readonly propertyName: JRightPadded<Java.Identifier> | null;
-            withPropertyName(propertyName: JRightPadded<Java.Identifier> | null): ObjectBindingDeclarations.Binding;
-            readonly initializer: JLeftPadded<Expression> | null;
-            withInitializer(initializer: JLeftPadded<Expression> | null): ObjectBindingDeclarations.Binding;
-        };
-    }
-    export {};
-}
 declare const PropertyAssignment_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -705,7 +702,7 @@ declare const PropertyAssignment_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class PropertyAssignment extends PropertyAssignment_base implements Statement, TypedTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, name: JRightPadded<Expression>, initializer: Expression);
+    constructor(id: UUID, prefix: Space, markers: Markers, name: JRightPadded<Expression>, initializer: Expression | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): PropertyAssignment;
@@ -719,8 +716,8 @@ export declare class PropertyAssignment extends PropertyAssignment_base implemen
     get name(): Expression;
     withName(name: Expression): PropertyAssignment;
     private readonly _initializer;
-    get initializer(): Expression;
-    withInitializer(initializer: Expression): PropertyAssignment;
+    get initializer(): Expression | null;
+    withInitializer(initializer: Expression | null): PropertyAssignment;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get type(): JavaType | null;
     withType(type: JavaType): PropertyAssignment;
@@ -753,7 +750,7 @@ declare const ScopedVariableDeclarations_base: ((abstract new (...args: any[]) =
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class ScopedVariableDeclarations extends ScopedVariableDeclarations_base implements Statement {
-    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], scope: JLeftPadded<ScopedVariableDeclarations.Scope> | null, variables: JRightPadded<Expression>[]);
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], scope: JLeftPadded<ScopedVariableDeclarations.Scope> | null, variables: JRightPadded<J>[]);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): ScopedVariableDeclarations;
@@ -770,14 +767,14 @@ export declare class ScopedVariableDeclarations extends ScopedVariableDeclaratio
     get scope(): ScopedVariableDeclarations.Scope | null;
     withScope(scope: ScopedVariableDeclarations.Scope | null): ScopedVariableDeclarations;
     private readonly _variables;
-    get variables(): Expression[];
-    withVariables(variables: Expression[]): ScopedVariableDeclarations;
+    get variables(): J[];
+    withVariables(variables: J[]): ScopedVariableDeclarations;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get padding(): {
         readonly scope: JLeftPadded<ScopedVariableDeclarations.Scope> | null;
         withScope(scope: JLeftPadded<ScopedVariableDeclarations.Scope> | null): ScopedVariableDeclarations;
-        readonly variables: JRightPadded<Expression>[];
-        withVariables(variables: JRightPadded<Expression>[]): ScopedVariableDeclarations;
+        readonly variables: JRightPadded<J>[];
+        withVariables(variables: JRightPadded<J>[]): ScopedVariableDeclarations;
     };
 }
 export declare namespace ScopedVariableDeclarations {
@@ -957,7 +954,7 @@ declare const TypeDeclaration_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class TypeDeclaration extends TypeDeclaration_base implements Statement, TypedTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], name: Java.Identifier, typeParameters: Java.TypeParameters | null, initializer: JLeftPadded<Expression>, _type: JavaType | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], name: Java.Identifier, typeParameters: Java.TypeParameters | null, initializer: JLeftPadded<Expression>, _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): TypeDeclaration;
@@ -967,9 +964,6 @@ export declare class TypeDeclaration extends TypeDeclaration_base implements Sta
     private readonly _markers;
     get markers(): Markers;
     withMarkers(markers: Markers): TypeDeclaration;
-    private readonly _leadingAnnotations;
-    get leadingAnnotations(): Java.Annotation[];
-    withLeadingAnnotations(leadingAnnotations: Java.Annotation[]): TypeDeclaration;
     private readonly _modifiers;
     get modifiers(): Java.Modifier[];
     withModifiers(modifiers: Java.Modifier[]): TypeDeclaration;
@@ -1033,6 +1027,48 @@ export declare class TypeOf extends TypeOf_base implements Expression {
     withType(_type: JavaType | null): TypeOf;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
 }
+declare const TypeQuery_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class TypeQuery extends TypeQuery_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, typeExpression: TypeTree, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeQuery;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeQuery;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeQuery;
+    private readonly _typeExpression;
+    get typeExpression(): TypeTree;
+    withTypeExpression(typeExpression: TypeTree): TypeQuery;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TypeQuery;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
 declare const TypeOperator_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -1141,7 +1177,8 @@ export declare namespace Unary {
         Spread = 0,
         Optional = 1,
         Exclamation = 2,
-        QuestionDot = 3
+        QuestionDot = 3,
+        QuestionDotWithDot = 4
     }
 }
 declare const Union_base: ((abstract new (...args: any[]) => {
@@ -1190,6 +1227,52 @@ export declare class Union extends Union_base implements Expression, TypeTree {
         withTypes(types: JRightPadded<Expression>[]): Union;
     };
 }
+declare const Intersection_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Intersection extends Intersection_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, types: JRightPadded<Expression>[], _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Intersection;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Intersection;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Intersection;
+    private readonly _types;
+    get types(): Expression[];
+    withTypes(types: Expression[]): Intersection;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Intersection;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly types: JRightPadded<Expression>[];
+        withTypes(types: JRightPadded<Expression>[]): Intersection;
+    };
+}
 declare const Void_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -1509,6 +1592,212 @@ export declare class JSMethodDeclaration extends JSMethodDeclaration_base implem
         withDefaultValue(defaultValue: JLeftPadded<Expression> | null): JSMethodDeclaration;
     };
 }
+declare const JSMethodInvocation_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JSMethodInvocation extends JSMethodInvocation_base implements Statement, TypedTree, MethodCall {
+    constructor(id: UUID, prefix: Space, markers: Markers, select: JRightPadded<Expression> | null, typeParameters: JContainer<Expression> | null, name: Expression, _arguments: JContainer<Expression>, methodType: JavaType.Method | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JSMethodInvocation;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JSMethodInvocation;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JSMethodInvocation;
+    private readonly _select;
+    get select(): Expression | null;
+    withSelect(select: Expression | null): JSMethodInvocation;
+    private readonly _typeParameters;
+    get typeParameters(): Expression[] | null;
+    withTypeParameters(typeParameters: Expression[] | null): JSMethodInvocation;
+    private readonly _name;
+    get name(): Expression;
+    withName(name: Expression): JSMethodInvocation;
+    private readonly _arguments;
+    get arguments(): Expression[];
+    withArguments(_arguments: Expression[]): JSMethodInvocation;
+    private readonly _methodType;
+    get methodType(): JavaType.Method | null;
+    withMethodType(methodType: JavaType.Method | null): JSMethodInvocation;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): JSMethodInvocation;
+    get padding(): {
+        readonly select: JRightPadded<Expression> | null;
+        withSelect(select: JRightPadded<Expression> | null): JSMethodInvocation;
+        readonly typeParameters: JContainer<Expression> | null;
+        withTypeParameters(typeParameters: JContainer<Expression> | null): JSMethodInvocation;
+        readonly arguments: JContainer<Expression>;
+        withArguments(_arguments: JContainer<Expression>): JSMethodInvocation;
+    };
+}
+declare const JSForOfLoop_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JSForOfLoop extends JSForOfLoop_base implements Loop {
+    constructor(id: UUID, prefix: Space, markers: Markers, await: JLeftPadded<boolean>, control: JSForInOfLoopControl, body: JRightPadded<Statement>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JSForOfLoop;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JSForOfLoop;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JSForOfLoop;
+    private readonly _await;
+    get await(): boolean;
+    withAwait(await: boolean): JSForOfLoop;
+    private readonly _control;
+    get control(): JSForInOfLoopControl;
+    withControl(control: JSForInOfLoopControl): JSForOfLoop;
+    private readonly _body;
+    get body(): Statement;
+    withBody(body: Statement): JSForOfLoop;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly await: JLeftPadded<boolean>;
+        withAwait(await: JLeftPadded<boolean>): JSForOfLoop;
+        readonly body: JRightPadded<Statement>;
+        withBody(body: JRightPadded<Statement>): JSForOfLoop;
+    };
+}
+declare const JSForInLoop_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JSForInLoop extends JSForInLoop_base implements Loop {
+    constructor(id: UUID, prefix: Space, markers: Markers, control: JSForInOfLoopControl, body: JRightPadded<Statement>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JSForInLoop;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JSForInLoop;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JSForInLoop;
+    private readonly _control;
+    get control(): JSForInOfLoopControl;
+    withControl(control: JSForInOfLoopControl): JSForInLoop;
+    private readonly _body;
+    get body(): Statement;
+    withBody(body: Statement): JSForInLoop;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly body: JRightPadded<Statement>;
+        withBody(body: JRightPadded<Statement>): JSForInLoop;
+    };
+}
+declare const JSForInOfLoopControl_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JSForInOfLoopControl extends JSForInOfLoopControl_base {
+    constructor(id: UUID, prefix: Space, markers: Markers, variable: JRightPadded<Statement>, iterable: JRightPadded<Expression>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JSForInOfLoopControl;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JSForInOfLoopControl;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JSForInOfLoopControl;
+    private readonly _variable;
+    get variable(): Statement;
+    withVariable(variable: Statement): JSForInOfLoopControl;
+    private readonly _iterable;
+    get iterable(): Expression;
+    withIterable(iterable: Expression): JSForInOfLoopControl;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly variable: JRightPadded<Statement>;
+        withVariable(variable: JRightPadded<Statement>): JSForInOfLoopControl;
+        readonly iterable: JRightPadded<Expression>;
+        withIterable(iterable: JRightPadded<Expression>): JSForInOfLoopControl;
+    };
+}
 declare const NamespaceDeclaration_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -1569,5 +1858,264 @@ export declare namespace NamespaceDeclaration {
         Module = 1
     }
 }
+declare const FunctionDeclaration_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class FunctionDeclaration extends FunctionDeclaration_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], name: Java.Identifier | null, typeParameters: Java.TypeParameters | null, parameters: JContainer<Statement>, returnTypeExpression: TypeTree | null, body: J, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): FunctionDeclaration;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): FunctionDeclaration;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): FunctionDeclaration;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): FunctionDeclaration;
+    private readonly _name;
+    get name(): Java.Identifier | null;
+    withName(name: Java.Identifier | null): FunctionDeclaration;
+    private readonly _typeParameters;
+    get typeParameters(): Java.TypeParameters | null;
+    withTypeParameters(typeParameters: Java.TypeParameters | null): FunctionDeclaration;
+    private readonly _parameters;
+    get parameters(): Statement[];
+    withParameters(parameters: Statement[]): FunctionDeclaration;
+    private readonly _returnTypeExpression;
+    get returnTypeExpression(): TypeTree | null;
+    withReturnTypeExpression(returnTypeExpression: TypeTree | null): FunctionDeclaration;
+    private readonly _body;
+    get body(): J;
+    withBody(body: J): FunctionDeclaration;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): FunctionDeclaration;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly parameters: JContainer<Statement>;
+        withParameters(parameters: JContainer<Statement>): FunctionDeclaration;
+    };
+}
+declare const TypeLiteral_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class TypeLiteral extends TypeLiteral_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, members: Java.Block, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeLiteral;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeLiteral;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeLiteral;
+    private readonly _members;
+    get members(): Java.Block;
+    withMembers(members: Java.Block): TypeLiteral;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TypeLiteral;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
+declare const IndexSignatureDeclaration_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class IndexSignatureDeclaration extends IndexSignatureDeclaration_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], parameters: JContainer<J>, typeExpression: JLeftPadded<Expression>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): IndexSignatureDeclaration;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): IndexSignatureDeclaration;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): IndexSignatureDeclaration;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): IndexSignatureDeclaration;
+    private readonly _parameters;
+    get parameters(): J[];
+    withParameters(parameters: J[]): IndexSignatureDeclaration;
+    private readonly _typeExpression;
+    get typeExpression(): Expression;
+    withTypeExpression(typeExpression: Expression): IndexSignatureDeclaration;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): IndexSignatureDeclaration;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly parameters: JContainer<J>;
+        withParameters(parameters: JContainer<J>): IndexSignatureDeclaration;
+        readonly typeExpression: JLeftPadded<Expression>;
+        withTypeExpression(typeExpression: JLeftPadded<Expression>): IndexSignatureDeclaration;
+    };
+}
+declare const ArrayBindingPattern_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class ArrayBindingPattern extends ArrayBindingPattern_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, elements: JContainer<Expression>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ArrayBindingPattern;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ArrayBindingPattern;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ArrayBindingPattern;
+    private readonly _elements;
+    get elements(): Expression[];
+    withElements(elements: Expression[]): ArrayBindingPattern;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ArrayBindingPattern;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly elements: JContainer<Expression>;
+        withElements(elements: JContainer<Expression>): ArrayBindingPattern;
+    };
+}
+declare const BindingElement_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class BindingElement extends BindingElement_base implements Statement, Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, propertyName: JRightPadded<Expression> | null, name: TypedTree, initializer: JLeftPadded<Expression> | null, variableType: JavaType.Variable | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): BindingElement;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): BindingElement;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): BindingElement;
+    private readonly _propertyName;
+    get propertyName(): Expression | null;
+    withPropertyName(propertyName: Expression | null): BindingElement;
+    private readonly _name;
+    get name(): TypedTree;
+    withName(name: TypedTree): BindingElement;
+    private readonly _initializer;
+    get initializer(): Expression | null;
+    withInitializer(initializer: Expression | null): BindingElement;
+    private readonly _variableType;
+    get variableType(): JavaType.Variable | null;
+    withVariableType(variableType: JavaType.Variable | null): BindingElement;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): BindingElement;
+    get padding(): {
+        readonly propertyName: JRightPadded<Expression> | null;
+        withPropertyName(propertyName: JRightPadded<Expression> | null): BindingElement;
+        readonly initializer: JLeftPadded<Expression> | null;
+        withInitializer(initializer: JLeftPadded<Expression> | null): BindingElement;
+    };
+}
 export {};
 //# sourceMappingURL=tree.d.ts.map