@openrewrite/rewrite 0.22.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, MethodCall } 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;
@@ -412,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;
@@ -422,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;
@@ -436,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;
     };
@@ -638,7 +643,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 +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;
@@ -667,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: 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 +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;
@@ -827,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 {
@@ -1014,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;
@@ -1024,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;
@@ -1090,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;
@@ -1248,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;
@@ -1628,6 +1653,151 @@ export declare class JSMethodInvocation extends JSMethodInvocation_base implemen
         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;
@@ -1749,5 +1919,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