@openrewrite/rewrite 0.22.0 → 0.22.2

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, MethodCall } from "../../java/tree";
+import { Expression, J, JavaSourceFile, JavaType, JContainer, JLeftPadded, JRightPadded, NameTree, Space, Statement, TypedTree, TypeTree, Loop } from "../../java/tree";
 import * as Java from "../../java/tree";
 declare const CompilationUnit_base: ((abstract new (...args: any[]) => {
     readonly sourcePath: string;
@@ -244,6 +244,55 @@ export declare class Await extends Await_base implements Expression {
     withType(_type: JavaType | null): Await;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
 }
+declare const ConditionalType_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 ConditionalType extends ConditionalType_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, checkType: Expression, condition: JContainer<TypedTree>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ConditionalType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ConditionalType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ConditionalType;
+    private readonly _checkType;
+    get checkType(): Expression;
+    withCheckType(checkType: Expression): ConditionalType;
+    private readonly _condition;
+    get condition(): TypedTree[];
+    withCondition(condition: TypedTree[]): ConditionalType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ConditionalType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly condition: JContainer<TypedTree>;
+        withCondition(condition: JContainer<TypedTree>): ConditionalType;
+    };
+}
 declare const DefaultType_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -388,6 +437,55 @@ export declare class Export extends Export_base implements Statement {
         withInitializer(initializer: JLeftPadded<Expression> | null): Export;
     };
 }
+declare const ExpressionWithTypeArguments_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 ExpressionWithTypeArguments extends ExpressionWithTypeArguments_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, clazz: NameTree, typeArguments: JContainer<Expression> | null, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ExpressionWithTypeArguments;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ExpressionWithTypeArguments;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ExpressionWithTypeArguments;
+    private readonly _clazz;
+    get clazz(): NameTree;
+    withClazz(clazz: NameTree): ExpressionWithTypeArguments;
+    private readonly _typeArguments;
+    get typeArguments(): Expression[] | null;
+    withTypeArguments(typeArguments: Expression[] | null): ExpressionWithTypeArguments;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ExpressionWithTypeArguments;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly typeArguments: JContainer<Expression> | null;
+        withTypeArguments(typeArguments: JContainer<Expression> | null): ExpressionWithTypeArguments;
+    };
+}
 declare const FunctionType_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -412,7 +510,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;
@@ -422,6 +520,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;
@@ -436,6 +537,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;
     };
@@ -638,7 +741,7 @@ declare const ObjectBindingDeclarations_base: ((abstract new (...args: any[]) =>
     isJavaScript: boolean;
 }) & ObjectConstructor;
 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<ObjectBindingDeclarations.Binding>, initializer: JLeftPadded<Expression> | null);
+    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;
@@ -658,8 +761,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;
@@ -667,77 +770,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: TypedTree, 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(): TypedTree;
-        withName(name: TypedTree): 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;
@@ -810,7 +848,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;
@@ -827,14 +865,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 {
@@ -844,6 +882,60 @@ export declare namespace ScopedVariableDeclarations {
         Var = 2
     }
 }
+declare const TaggedTemplateExpression_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 TaggedTemplateExpression extends TaggedTemplateExpression_base implements Statement, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, tag: JRightPadded<Expression> | null, typeArguments: JContainer<Expression> | null, templateExpression: TemplateExpression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TaggedTemplateExpression;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TaggedTemplateExpression;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TaggedTemplateExpression;
+    private readonly _tag;
+    get tag(): Expression | null;
+    withTag(tag: Expression | null): TaggedTemplateExpression;
+    private readonly _typeArguments;
+    get typeArguments(): Expression[] | null;
+    withTypeArguments(typeArguments: Expression[] | null): TaggedTemplateExpression;
+    private readonly _templateExpression;
+    get templateExpression(): TemplateExpression;
+    withTemplateExpression(templateExpression: TemplateExpression): TaggedTemplateExpression;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TaggedTemplateExpression;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly tag: JRightPadded<Expression> | null;
+        withTag(tag: JRightPadded<Expression> | null): TaggedTemplateExpression;
+        readonly typeArguments: JContainer<Expression> | null;
+        withTypeArguments(typeArguments: JContainer<Expression> | null): TaggedTemplateExpression;
+    };
+}
 declare const TemplateExpression_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -868,7 +960,7 @@ declare const TemplateExpression_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class TemplateExpression extends TemplateExpression_base implements Statement, Expression {
-    constructor(id: UUID, prefix: Space, markers: Markers, delimiter: string, tag: JRightPadded<Expression> | null, strings: J[], _type: JavaType | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, head: Java.Literal, templateSpans: JRightPadded<TemplateExpression.TemplateSpan>[], _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): TemplateExpression;
@@ -878,26 +970,23 @@ export declare class TemplateExpression extends TemplateExpression_base implemen
     private readonly _markers;
     get markers(): Markers;
     withMarkers(markers: Markers): TemplateExpression;
-    private readonly _delimiter;
-    get delimiter(): string;
-    withDelimiter(delimiter: string): TemplateExpression;
-    private readonly _tag;
-    get tag(): Expression | null;
-    withTag(tag: Expression | null): TemplateExpression;
-    private readonly _strings;
-    get strings(): J[];
-    withStrings(strings: J[]): TemplateExpression;
+    private readonly _head;
+    get head(): Java.Literal;
+    withHead(head: Java.Literal): TemplateExpression;
+    private readonly _templateSpans;
+    get templateSpans(): TemplateExpression.TemplateSpan[];
+    withTemplateSpans(templateSpans: TemplateExpression.TemplateSpan[]): TemplateExpression;
     private readonly _type;
     get type(): JavaType | null;
     withType(_type: JavaType | null): TemplateExpression;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get padding(): {
-        readonly tag: JRightPadded<Expression> | null;
-        withTag(tag: JRightPadded<Expression> | null): TemplateExpression;
+        readonly templateSpans: JRightPadded<TemplateExpression.TemplateSpan>[];
+        withTemplateSpans(templateSpans: JRightPadded<TemplateExpression.TemplateSpan>[]): TemplateExpression;
     };
 }
 export declare namespace TemplateExpression {
-    const Value_base: ((abstract new (...args: any[]) => {
+    const TemplateSpan_base: ((abstract new (...args: any[]) => {
         readonly prefix: Space;
         withPrefix(prefix: Space): JS;
         readonly id: Uint8Array;
@@ -920,26 +1009,23 @@ export declare namespace TemplateExpression {
         isJava: boolean;
         isJavaScript: boolean;
     }) & ObjectConstructor;
-    export class Value extends Value_base {
-        constructor(id: UUID, prefix: Space, markers: Markers, tree: J, after: Space, enclosedInBraces: boolean);
+    export class TemplateSpan extends TemplateSpan_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, expression: J, tail: Java.Literal);
         private readonly _id;
         get id(): UUID;
-        withId(id: UUID): TemplateExpression.Value;
+        withId(id: UUID): TemplateExpression.TemplateSpan;
         private readonly _prefix;
         get prefix(): Space;
-        withPrefix(prefix: Space): TemplateExpression.Value;
+        withPrefix(prefix: Space): TemplateExpression.TemplateSpan;
         private readonly _markers;
         get markers(): Markers;
-        withMarkers(markers: Markers): TemplateExpression.Value;
-        private readonly _tree;
-        get tree(): J;
-        withTree(tree: J): TemplateExpression.Value;
-        private readonly _after;
-        get after(): Space;
-        withAfter(after: Space): TemplateExpression.Value;
-        private readonly _enclosedInBraces;
-        get enclosedInBraces(): boolean;
-        withEnclosedInBraces(enclosedInBraces: boolean): TemplateExpression.Value;
+        withMarkers(markers: Markers): TemplateExpression.TemplateSpan;
+        private readonly _expression;
+        get expression(): J;
+        withExpression(expression: J): TemplateExpression.TemplateSpan;
+        private readonly _tail;
+        get tail(): Java.Literal;
+        withTail(tail: Java.Literal): TemplateExpression.TemplateSpan;
         acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     }
     export {};
@@ -1014,7 +1100,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: JLeftPadded<Java.Identifier>, typeParameters: Java.TypeParameters | null, initializer: JLeftPadded<Expression>, _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): TypeDeclaration;
@@ -1024,9 +1110,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;
@@ -1044,6 +1127,8 @@ export declare class TypeDeclaration extends TypeDeclaration_base implements Sta
     withType(_type: JavaType | null): TypeDeclaration;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get padding(): {
+        readonly name: JLeftPadded<Java.Identifier>;
+        withName(name: JLeftPadded<Java.Identifier>): TypeDeclaration;
         readonly initializer: JLeftPadded<Expression>;
         withInitializer(initializer: JLeftPadded<Expression>): TypeDeclaration;
     };
@@ -1090,6 +1175,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;
@@ -1248,6 +1375,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;
@@ -1567,7 +1740,7 @@ export declare class JSMethodDeclaration extends JSMethodDeclaration_base implem
         withDefaultValue(defaultValue: JLeftPadded<Expression> | null): JSMethodDeclaration;
     };
 }
-declare const JSMethodInvocation_base: ((abstract new (...args: any[]) => {
+declare const JSForOfLoop_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
     readonly id: Uint8Array;
@@ -1590,42 +1763,126 @@ declare const JSMethodInvocation_base: ((abstract new (...args: any[]) => {
     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);
+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): JSMethodInvocation;
+    withId(id: UUID): JSForOfLoop;
     private readonly _prefix;
     get prefix(): Space;
-    withPrefix(prefix: Space): JSMethodInvocation;
+    withPrefix(prefix: Space): JSForOfLoop;
     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;
+    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 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;
+        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[]) => {
@@ -1749,5 +2006,203 @@ export declare class FunctionDeclaration extends FunctionDeclaration_base implem
         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