@openrewrite/rewrite 0.18.0

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

@@ -0,0 +1,3377 @@
+import { J, Expression, JavaSourceFile, JavaType, JContainer, JLeftPadded, JRightPadded, Loop, MethodCall, NameTree, Space, Statement, TypedTree, TypeTree } from "./support_types";
+import { JavaVisitor } from "../visitor";
+import { Checksum, Cursor, FileAttributes, Markers, PrintOutputCapture, SourceFile, Tree, TreeVisitor, UUID } from "../../core";
+declare const AnnotatedType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class AnnotatedType extends AnnotatedType_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], typeExpression: TypeTree);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): AnnotatedType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): AnnotatedType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): AnnotatedType;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): AnnotatedType;
+    private readonly _typeExpression;
+    get typeExpression(): TypeTree;
+    withTypeExpression(typeExpression: TypeTree): AnnotatedType;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): AnnotatedType;
+}
+declare const Annotation_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Annotation extends Annotation_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotationType: NameTree, _arguments: JContainer<Expression> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Annotation;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Annotation;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Annotation;
+    private readonly _annotationType;
+    get annotationType(): NameTree;
+    withAnnotationType(annotationType: NameTree): Annotation;
+    private readonly _arguments;
+    get arguments(): Expression[] | null;
+    withArguments(_arguments: Expression[] | null): Annotation;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Annotation;
+    get padding(): {
+        readonly arguments: JContainer<Expression> | null;
+        withArguments(_arguments: JContainer<Expression> | null): Annotation;
+    };
+}
+declare const ArrayAccess_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ArrayAccess extends ArrayAccess_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, indexed: Expression, dimension: ArrayDimension, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ArrayAccess;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ArrayAccess;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ArrayAccess;
+    private readonly _indexed;
+    get indexed(): Expression;
+    withIndexed(indexed: Expression): ArrayAccess;
+    private readonly _dimension;
+    get dimension(): ArrayDimension;
+    withDimension(dimension: ArrayDimension): ArrayAccess;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ArrayAccess;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const ArrayType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ArrayType extends ArrayType_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, elementType: TypeTree, annotations: Annotation[] | null, dimension: JLeftPadded<Space> | null, _type: JavaType);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ArrayType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ArrayType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ArrayType;
+    private readonly _elementType;
+    get elementType(): TypeTree;
+    withElementType(elementType: TypeTree): ArrayType;
+    private readonly _annotations;
+    get annotations(): Annotation[] | null;
+    withAnnotations(annotations: Annotation[] | null): ArrayType;
+    private readonly _dimension;
+    get dimension(): JLeftPadded<Space> | null;
+    withDimension(dimension: JLeftPadded<Space> | null): ArrayType;
+    private readonly _type;
+    get type(): JavaType;
+    withType(_type: JavaType): ArrayType;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Assert_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Assert extends Assert_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, condition: Expression, detail: JLeftPadded<Expression> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Assert;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Assert;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Assert;
+    private readonly _condition;
+    get condition(): Expression;
+    withCondition(condition: Expression): Assert;
+    private readonly _detail;
+    get detail(): JLeftPadded<Expression> | null;
+    withDetail(detail: JLeftPadded<Expression> | null): Assert;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Assignment_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Assignment extends Assignment_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, variable: Expression, assignment: JLeftPadded<Expression>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Assignment;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Assignment;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Assignment;
+    private readonly _variable;
+    get variable(): Expression;
+    withVariable(variable: Expression): Assignment;
+    private readonly _assignment;
+    get assignment(): Expression;
+    withAssignment(assignment: Expression): Assignment;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Assignment;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly assignment: JLeftPadded<Expression>;
+        withAssignment(assignment: JLeftPadded<Expression>): Assignment;
+    };
+}
+declare const AssignmentOperation_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class AssignmentOperation extends AssignmentOperation_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, variable: Expression, operator: JLeftPadded<AssignmentOperation.Type>, assignment: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): AssignmentOperation;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): AssignmentOperation;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): AssignmentOperation;
+    private readonly _variable;
+    get variable(): Expression;
+    withVariable(variable: Expression): AssignmentOperation;
+    private readonly _operator;
+    get operator(): AssignmentOperation.Type;
+    withOperator(operator: AssignmentOperation.Type): AssignmentOperation;
+    private readonly _assignment;
+    get assignment(): Expression;
+    withAssignment(assignment: Expression): AssignmentOperation;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): AssignmentOperation;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly operator: JLeftPadded<AssignmentOperation.Type>;
+        withOperator(operator: JLeftPadded<AssignmentOperation.Type>): AssignmentOperation;
+    };
+}
+export declare namespace AssignmentOperation {
+    enum Type {
+        Addition = 0,
+        BitAnd = 1,
+        BitOr = 2,
+        BitXor = 3,
+        Division = 4,
+        Exponentiation = 5,
+        FloorDivision = 6,
+        LeftShift = 7,
+        MatrixMultiplication = 8,
+        Modulo = 9,
+        Multiplication = 10,
+        RightShift = 11,
+        Subtraction = 12,
+        UnsignedRightShift = 13
+    }
+}
+declare const Binary_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Binary extends Binary_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, left: Expression, operator: JLeftPadded<Binary.Type>, right: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Binary;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Binary;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Binary;
+    private readonly _left;
+    get left(): Expression;
+    withLeft(left: Expression): Binary;
+    private readonly _operator;
+    get operator(): Binary.Type;
+    withOperator(operator: Binary.Type): Binary;
+    private readonly _right;
+    get right(): Expression;
+    withRight(right: Expression): Binary;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Binary;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly operator: JLeftPadded<Binary.Type>;
+        withOperator(operator: JLeftPadded<Binary.Type>): Binary;
+    };
+}
+export declare namespace Binary {
+    enum Type {
+        Addition = 0,
+        Subtraction = 1,
+        Multiplication = 2,
+        Division = 3,
+        Modulo = 4,
+        LessThan = 5,
+        GreaterThan = 6,
+        LessThanOrEqual = 7,
+        GreaterThanOrEqual = 8,
+        Equal = 9,
+        NotEqual = 10,
+        BitAnd = 11,
+        BitOr = 12,
+        BitXor = 13,
+        LeftShift = 14,
+        RightShift = 15,
+        UnsignedRightShift = 16,
+        Or = 17,
+        And = 18
+    }
+}
+declare const Block_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Block extends Block_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, _static: JRightPadded<boolean>, statements: JRightPadded<Statement>[], end: Space);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Block;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Block;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Block;
+    private readonly _static;
+    get static(): boolean;
+    withStatic(_static: boolean): Block;
+    private readonly _statements;
+    get statements(): Statement[];
+    withStatements(statements: Statement[]): Block;
+    private readonly _end;
+    get end(): Space;
+    withEnd(end: Space): Block;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly static: JRightPadded<boolean>;
+        withStatic(_static: JRightPadded<boolean>): Block;
+        readonly statements: JRightPadded<Statement>[];
+        withStatements(statements: JRightPadded<Statement>[]): Block;
+    };
+}
+declare const Break_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Break extends Break_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, label: Identifier | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Break;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Break;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Break;
+    private readonly _label;
+    get label(): Identifier | null;
+    withLabel(label: Identifier | null): Break;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Case_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Case extends Case_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, _type: Case.Type, expressions: JContainer<Expression>, statements: JContainer<Statement>, body: JRightPadded<J> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Case;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Case;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Case;
+    private readonly _type;
+    get type(): Case.Type;
+    withType(_type: Case.Type): Case;
+    private readonly _expressions;
+    get expressions(): Expression[];
+    withExpressions(expressions: Expression[]): Case;
+    private readonly _statements;
+    get statements(): Statement[];
+    withStatements(statements: Statement[]): Case;
+    private readonly _body;
+    get body(): J | null;
+    withBody(body: J | null): Case;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly expressions: JContainer<Expression>;
+        withExpressions(expressions: JContainer<Expression>): Case;
+        readonly statements: JContainer<Statement>;
+        withStatements(statements: JContainer<Statement>): Case;
+        readonly body: JRightPadded<J> | null;
+        withBody(body: JRightPadded<J> | null): Case;
+    };
+}
+export declare namespace Case {
+    enum Type {
+        Statement = 0,
+        Rule = 1
+    }
+}
+declare const ClassDeclaration_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ClassDeclaration extends ClassDeclaration_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Annotation[], modifiers: Modifier[], kind: ClassDeclaration.Kind, name: Identifier, typeParameters: JContainer<TypeParameter> | null, primaryConstructor: JContainer<Statement> | null, _extends: JLeftPadded<TypeTree> | null, _implements: JContainer<TypeTree> | null, permits: JContainer<TypeTree> | null, body: Block, _type: JavaType.FullyQualified | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ClassDeclaration;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ClassDeclaration;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ClassDeclaration;
+    private readonly _leadingAnnotations;
+    get leadingAnnotations(): Annotation[];
+    withLeadingAnnotations(leadingAnnotations: Annotation[]): ClassDeclaration;
+    private readonly _modifiers;
+    get modifiers(): Modifier[];
+    withModifiers(modifiers: Modifier[]): ClassDeclaration;
+    private readonly _kind;
+    withKind(kind: ClassDeclaration.Kind): ClassDeclaration;
+    private readonly _name;
+    get name(): Identifier;
+    withName(name: Identifier): ClassDeclaration;
+    private readonly _typeParameters;
+    get typeParameters(): TypeParameter[] | null;
+    withTypeParameters(typeParameters: TypeParameter[] | null): ClassDeclaration;
+    private readonly _primaryConstructor;
+    get primaryConstructor(): Statement[] | null;
+    withPrimaryConstructor(primaryConstructor: Statement[] | null): ClassDeclaration;
+    private readonly _extends;
+    get extends(): TypeTree | null;
+    withExtends(_extends: TypeTree | null): ClassDeclaration;
+    private readonly _implements;
+    get implements(): TypeTree[] | null;
+    withImplements(_implements: TypeTree[] | null): ClassDeclaration;
+    private readonly _permits;
+    get permits(): TypeTree[] | null;
+    withPermits(permits: TypeTree[] | null): ClassDeclaration;
+    private readonly _body;
+    get body(): Block;
+    withBody(body: Block): ClassDeclaration;
+    private readonly _type;
+    get type(): JavaType.FullyQualified | null;
+    withType(_type: JavaType.FullyQualified | null): ClassDeclaration;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly kind: ClassDeclaration.Kind;
+        withKind(kind: ClassDeclaration.Kind): ClassDeclaration;
+        readonly typeParameters: JContainer<TypeParameter> | null;
+        withTypeParameters(typeParameters: JContainer<TypeParameter> | null): ClassDeclaration;
+        readonly primaryConstructor: JContainer<Statement> | null;
+        withPrimaryConstructor(primaryConstructor: JContainer<Statement> | null): ClassDeclaration;
+        readonly extends: JLeftPadded<TypeTree> | null;
+        withExtends(_extends: JLeftPadded<TypeTree> | null): ClassDeclaration;
+        readonly implements: JContainer<TypeTree> | null;
+        withImplements(_implements: JContainer<TypeTree> | null): ClassDeclaration;
+        readonly permits: JContainer<TypeTree> | null;
+        withPermits(permits: JContainer<TypeTree> | null): ClassDeclaration;
+    };
+}
+export declare namespace ClassDeclaration {
+    const Kind_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Kind extends Kind_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], _type: ClassDeclaration.Kind.Type);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): ClassDeclaration.Kind;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): ClassDeclaration.Kind;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): ClassDeclaration.Kind;
+        private readonly _annotations;
+        get annotations(): Annotation[];
+        withAnnotations(annotations: Annotation[]): ClassDeclaration.Kind;
+        private readonly _type;
+        get type(): ClassDeclaration.Kind.Type;
+        withType(_type: ClassDeclaration.Kind.Type): ClassDeclaration.Kind;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    }
+    export namespace Kind {
+        enum Type {
+            Class = 0,
+            Enum = 1,
+            Interface = 2,
+            Annotation = 3,
+            Record = 4,
+            Value = 5
+        }
+    }
+    export {};
+}
+declare const CompilationUnit_base: ((abstract new (...args: any[]) => {
+    readonly sourcePath: string;
+    withSourcePath(sourcePath: string): SourceFile;
+    readonly charsetName: string | null;
+    withCharsetName(charset: string | null): SourceFile;
+    readonly charsetBomMarked: boolean;
+    withCharsetBomMarked(isCharsetBomMarked: boolean): SourceFile;
+    readonly checksum: Checksum | null;
+    withChecksum(checksum: Checksum | null): SourceFile;
+    readonly fileAttributes: FileAttributes | null;
+    withFileAttributes(fileAttributes: FileAttributes | null): SourceFile;
+    printEqualsInput(parserInput: import("../../core").ParserInput, ctx: import("../../core").ExecutionContext): boolean;
+    printAll(): string;
+    print<P>(cursor: Cursor, capture: PrintOutputCapture<P>): string;
+    printer<P>(cursor: Cursor): TreeVisitor<any, PrintOutputCapture<P>>;
+    readonly id: Uint8Array;
+    withId(id: UUID): Tree;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): Tree;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+}) & {
+    isTree: boolean;
+    isSourceFile: boolean;
+}) & ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class CompilationUnit extends CompilationUnit_base implements JavaSourceFile {
+    constructor(id: UUID, prefix: Space, markers: Markers, sourcePath: string, fileAttributes: FileAttributes | null, charsetName: string | null, charsetBomMarked: boolean, checksum: Checksum | null, packageDeclaration: JRightPadded<Package> | null, imports: JRightPadded<Import>[], classes: ClassDeclaration[], eof: Space);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): CompilationUnit;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): CompilationUnit;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): CompilationUnit;
+    private readonly _sourcePath;
+    get sourcePath(): string;
+    withSourcePath(sourcePath: string): CompilationUnit;
+    private readonly _fileAttributes;
+    get fileAttributes(): FileAttributes | null;
+    withFileAttributes(fileAttributes: FileAttributes | null): CompilationUnit;
+    private readonly _charsetName;
+    get charsetName(): string | null;
+    withCharsetName(charsetName: string | null): CompilationUnit;
+    private readonly _charsetBomMarked;
+    get charsetBomMarked(): boolean;
+    withCharsetBomMarked(charsetBomMarked: boolean): CompilationUnit;
+    private readonly _checksum;
+    get checksum(): Checksum | null;
+    withChecksum(checksum: Checksum | null): CompilationUnit;
+    private readonly _packageDeclaration;
+    get packageDeclaration(): Package | null;
+    withPackageDeclaration(packageDeclaration: Package | null): CompilationUnit;
+    private readonly _imports;
+    get imports(): Import[];
+    withImports(imports: Import[]): CompilationUnit;
+    private readonly _classes;
+    get classes(): ClassDeclaration[];
+    withClasses(classes: ClassDeclaration[]): CompilationUnit;
+    private readonly _eof;
+    get eof(): Space;
+    withEof(eof: Space): CompilationUnit;
+    printer<P>(cursor: Cursor): TreeVisitor<Tree, PrintOutputCapture<P>>;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly packageDeclaration: JRightPadded<Package> | null;
+        withPackageDeclaration(packageDeclaration: JRightPadded<Package> | null): CompilationUnit;
+        readonly imports: JRightPadded<Import>[];
+        withImports(imports: JRightPadded<Import>[]): CompilationUnit;
+    };
+}
+declare const Continue_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Continue extends Continue_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, label: Identifier | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Continue;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Continue;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Continue;
+    private readonly _label;
+    get label(): Identifier | null;
+    withLabel(label: Identifier | null): Continue;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const DoWhileLoop_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class DoWhileLoop extends DoWhileLoop_base implements Loop {
+    constructor(id: UUID, prefix: Space, markers: Markers, body: JRightPadded<Statement>, whileCondition: JLeftPadded<ControlParentheses<Expression>>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): DoWhileLoop;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): DoWhileLoop;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): DoWhileLoop;
+    private readonly _body;
+    get body(): Statement;
+    withBody(body: Statement): DoWhileLoop;
+    private readonly _whileCondition;
+    get whileCondition(): ControlParentheses<Expression>;
+    withWhileCondition(whileCondition: ControlParentheses<Expression>): DoWhileLoop;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly body: JRightPadded<Statement>;
+        withBody(body: JRightPadded<Statement>): DoWhileLoop;
+        readonly whileCondition: JLeftPadded<ControlParentheses<Expression>>;
+        withWhileCondition(whileCondition: JLeftPadded<ControlParentheses<Expression>>): DoWhileLoop;
+    };
+}
+declare const Empty_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Empty extends Empty_base implements Statement, Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Empty;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Empty;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Empty;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Empty;
+}
+declare const EnumValue_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class EnumValue extends EnumValue_base {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], name: Identifier, initializer: NewClass | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): EnumValue;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): EnumValue;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): EnumValue;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): EnumValue;
+    private readonly _name;
+    get name(): Identifier;
+    withName(name: Identifier): EnumValue;
+    private readonly _initializer;
+    get initializer(): NewClass | null;
+    withInitializer(initializer: NewClass | null): EnumValue;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const EnumValueSet_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class EnumValueSet extends EnumValueSet_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, enums: JRightPadded<EnumValue>[], terminatedWithSemicolon: boolean);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): EnumValueSet;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): EnumValueSet;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): EnumValueSet;
+    private readonly _enums;
+    get enums(): EnumValue[];
+    withEnums(enums: EnumValue[]): EnumValueSet;
+    private readonly _terminatedWithSemicolon;
+    get terminatedWithSemicolon(): boolean;
+    withTerminatedWithSemicolon(terminatedWithSemicolon: boolean): EnumValueSet;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly enums: JRightPadded<EnumValue>[];
+        withEnums(enums: JRightPadded<EnumValue>[]): EnumValueSet;
+    };
+}
+declare const FieldAccess_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class FieldAccess extends FieldAccess_base implements TypeTree, Expression, Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, target: Expression, name: JLeftPadded<Identifier>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): FieldAccess;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): FieldAccess;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): FieldAccess;
+    private readonly _target;
+    get target(): Expression;
+    withTarget(target: Expression): FieldAccess;
+    private readonly _name;
+    get name(): Identifier;
+    withName(name: Identifier): FieldAccess;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): FieldAccess;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly name: JLeftPadded<Identifier>;
+        withName(name: JLeftPadded<Identifier>): FieldAccess;
+    };
+}
+declare const ForEachLoop_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ForEachLoop extends ForEachLoop_base implements Loop {
+    constructor(id: UUID, prefix: Space, markers: Markers, control: ForEachLoop.Control, body: JRightPadded<Statement>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ForEachLoop;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ForEachLoop;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ForEachLoop;
+    private readonly _control;
+    get control(): ForEachLoop.Control;
+    withControl(control: ForEachLoop.Control): ForEachLoop;
+    private readonly _body;
+    get body(): Statement;
+    withBody(body: Statement): ForEachLoop;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly body: JRightPadded<Statement>;
+        withBody(body: JRightPadded<Statement>): ForEachLoop;
+    };
+}
+export declare namespace ForEachLoop {
+    const Control_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Control extends Control_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, variable: JRightPadded<VariableDeclarations>, iterable: JRightPadded<Expression>);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): ForEachLoop.Control;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): ForEachLoop.Control;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): ForEachLoop.Control;
+        private readonly _variable;
+        get variable(): VariableDeclarations;
+        withVariable(variable: VariableDeclarations): ForEachLoop.Control;
+        private readonly _iterable;
+        get iterable(): Expression;
+        withIterable(iterable: Expression): ForEachLoop.Control;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+        get padding(): {
+            readonly variable: JRightPadded<VariableDeclarations>;
+            withVariable(variable: JRightPadded<VariableDeclarations>): ForEachLoop.Control;
+            readonly iterable: JRightPadded<Expression>;
+            withIterable(iterable: JRightPadded<Expression>): ForEachLoop.Control;
+        };
+    }
+    export {};
+}
+declare const ForLoop_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ForLoop extends ForLoop_base implements Loop {
+    constructor(id: UUID, prefix: Space, markers: Markers, control: ForLoop.Control, body: JRightPadded<Statement>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ForLoop;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ForLoop;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ForLoop;
+    private readonly _control;
+    get control(): ForLoop.Control;
+    withControl(control: ForLoop.Control): ForLoop;
+    private readonly _body;
+    get body(): Statement;
+    withBody(body: Statement): ForLoop;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly body: JRightPadded<Statement>;
+        withBody(body: JRightPadded<Statement>): ForLoop;
+    };
+}
+export declare namespace ForLoop {
+    const Control_base_1: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Control extends Control_base_1 {
+        constructor(id: UUID, prefix: Space, markers: Markers, init: JRightPadded<Statement>[], condition: JRightPadded<Expression>, update: JRightPadded<Statement>[]);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): ForLoop.Control;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): ForLoop.Control;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): ForLoop.Control;
+        private readonly _init;
+        get init(): Statement[];
+        withInit(init: Statement[]): ForLoop.Control;
+        private readonly _condition;
+        get condition(): Expression;
+        withCondition(condition: Expression): ForLoop.Control;
+        private readonly _update;
+        get update(): Statement[];
+        withUpdate(update: Statement[]): ForLoop.Control;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+        get padding(): {
+            readonly init: JRightPadded<Statement>[];
+            withInit(init: JRightPadded<Statement>[]): ForLoop.Control;
+            readonly condition: JRightPadded<Expression>;
+            withCondition(condition: JRightPadded<Expression>): ForLoop.Control;
+            readonly update: JRightPadded<Statement>[];
+            withUpdate(update: JRightPadded<Statement>[]): ForLoop.Control;
+        };
+    }
+    export {};
+}
+declare const ParenthesizedTypeTree_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ParenthesizedTypeTree extends ParenthesizedTypeTree_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], parenthesizedType: Parentheses<TypeTree>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ParenthesizedTypeTree;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ParenthesizedTypeTree;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ParenthesizedTypeTree;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): ParenthesizedTypeTree;
+    private readonly _parenthesizedType;
+    get parenthesizedType(): Parentheses<TypeTree>;
+    withParenthesizedType(parenthesizedType: Parentheses<TypeTree>): ParenthesizedTypeTree;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): ParenthesizedTypeTree;
+}
+declare const Identifier_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Identifier extends Identifier_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], simpleName: string, _type: JavaType | null, fieldType: JavaType.Variable | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Identifier;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Identifier;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Identifier;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): Identifier;
+    private readonly _simpleName;
+    get simpleName(): string;
+    withSimpleName(simpleName: string): Identifier;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Identifier;
+    private readonly _fieldType;
+    get fieldType(): JavaType.Variable | null;
+    withFieldType(fieldType: JavaType.Variable | null): Identifier;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const If_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class If extends If_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, ifCondition: ControlParentheses<Expression>, thenPart: JRightPadded<Statement>, elsePart: If.Else | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): If;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): If;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): If;
+    private readonly _ifCondition;
+    get ifCondition(): ControlParentheses<Expression>;
+    withIfCondition(ifCondition: ControlParentheses<Expression>): If;
+    private readonly _thenPart;
+    get thenPart(): Statement;
+    withThenPart(thenPart: Statement): If;
+    private readonly _elsePart;
+    get elsePart(): If.Else | null;
+    withElsePart(elsePart: If.Else | null): If;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly thenPart: JRightPadded<Statement>;
+        withThenPart(thenPart: JRightPadded<Statement>): If;
+    };
+}
+export declare namespace If {
+    const Else_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Else extends Else_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, body: JRightPadded<Statement>);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): If.Else;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): If.Else;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): If.Else;
+        private readonly _body;
+        get body(): Statement;
+        withBody(body: Statement): If.Else;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+        get padding(): {
+            readonly body: JRightPadded<Statement>;
+            withBody(body: JRightPadded<Statement>): If.Else;
+        };
+    }
+    export {};
+}
+declare const Import_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Import extends Import_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, _static: JLeftPadded<boolean>, qualid: FieldAccess, alias: JLeftPadded<Identifier> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Import;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Import;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Import;
+    private readonly _static;
+    get static(): boolean;
+    withStatic(_static: boolean): Import;
+    private readonly _qualid;
+    get qualid(): FieldAccess;
+    withQualid(qualid: FieldAccess): Import;
+    private readonly _alias;
+    get alias(): Identifier | null;
+    withAlias(alias: Identifier | null): Import;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly static: JLeftPadded<boolean>;
+        withStatic(_static: JLeftPadded<boolean>): Import;
+        readonly alias: JLeftPadded<Identifier> | null;
+        withAlias(alias: JLeftPadded<Identifier> | null): Import;
+    };
+}
+declare const InstanceOf_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class InstanceOf extends InstanceOf_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: JRightPadded<Expression>, clazz: J, pattern: J | null, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): InstanceOf;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): InstanceOf;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): InstanceOf;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): InstanceOf;
+    private readonly _clazz;
+    get clazz(): J;
+    withClazz(clazz: J): InstanceOf;
+    private readonly _pattern;
+    get pattern(): J | null;
+    withPattern(pattern: J | null): InstanceOf;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): InstanceOf;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly expression: JRightPadded<Expression>;
+        withExpression(expression: JRightPadded<Expression>): InstanceOf;
+    };
+}
+declare const IntersectionType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class IntersectionType extends IntersectionType_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, bounds: JContainer<TypeTree>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): IntersectionType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): IntersectionType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): IntersectionType;
+    private readonly _bounds;
+    get bounds(): TypeTree[];
+    withBounds(bounds: TypeTree[]): IntersectionType;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): IntersectionType;
+    get padding(): {
+        readonly bounds: JContainer<TypeTree>;
+        withBounds(bounds: JContainer<TypeTree>): IntersectionType;
+    };
+}
+declare const Label_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Label extends Label_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, label: JRightPadded<Identifier>, statement: Statement);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Label;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Label;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Label;
+    private readonly _label;
+    get label(): Identifier;
+    withLabel(label: Identifier): Label;
+    private readonly _statement;
+    get statement(): Statement;
+    withStatement(statement: Statement): Label;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly label: JRightPadded<Identifier>;
+        withLabel(label: JRightPadded<Identifier>): Label;
+    };
+}
+declare const Lambda_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Lambda extends Lambda_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, parameters: Lambda.Parameters, arrow: Space, body: J, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Lambda;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Lambda;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Lambda;
+    private readonly _parameters;
+    get parameters(): Lambda.Parameters;
+    withParameters(parameters: Lambda.Parameters): Lambda;
+    private readonly _arrow;
+    get arrow(): Space;
+    withArrow(arrow: Space): Lambda;
+    private readonly _body;
+    get body(): J;
+    withBody(body: J): Lambda;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Lambda;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+export declare namespace Lambda {
+    const Parameters_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Parameters extends Parameters_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, parenthesized: boolean, parameters: JRightPadded<J>[]);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): Lambda.Parameters;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): Lambda.Parameters;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): Lambda.Parameters;
+        private readonly _parenthesized;
+        get parenthesized(): boolean;
+        withParenthesized(parenthesized: boolean): Lambda.Parameters;
+        private readonly _parameters;
+        get parameters(): J[];
+        withParameters(parameters: J[]): Lambda.Parameters;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+        get padding(): {
+            readonly parameters: JRightPadded<J>[];
+            withParameters(parameters: JRightPadded<J>[]): Lambda.Parameters;
+        };
+    }
+    export {};
+}
+declare const Literal_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Literal extends Literal_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, value: Object | null, valueSource: string | null, unicodeEscapes: Literal.UnicodeEscape[] | null, _type: JavaType.Primitive);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Literal;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Literal;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Literal;
+    private readonly _value;
+    get value(): Object | null;
+    withValue(value: Object | null): Literal;
+    private readonly _valueSource;
+    get valueSource(): string | null;
+    withValueSource(valueSource: string | null): Literal;
+    private readonly _unicodeEscapes;
+    get unicodeEscapes(): Literal.UnicodeEscape[] | null;
+    withUnicodeEscapes(unicodeEscapes: Literal.UnicodeEscape[] | null): Literal;
+    private readonly _type;
+    get type(): JavaType.Primitive;
+    withType(_type: JavaType.Primitive): Literal;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+export declare namespace Literal {
+    class UnicodeEscape {
+        constructor(valueSourceIndex: number, codePoint: string);
+        private readonly _valueSourceIndex;
+        get valueSourceIndex(): number;
+        withValueSourceIndex(valueSourceIndex: number): Literal.UnicodeEscape;
+        private readonly _codePoint;
+        get codePoint(): string;
+        withCodePoint(codePoint: string): Literal.UnicodeEscape;
+    }
+}
+declare const MemberReference_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class MemberReference extends MemberReference_base implements TypedTree, MethodCall {
+    constructor(id: UUID, prefix: Space, markers: Markers, containing: JRightPadded<Expression>, typeParameters: JContainer<Expression> | null, reference: JLeftPadded<Identifier>, _type: JavaType | null, methodType: JavaType.Method | null, variableType: JavaType.Variable | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): MemberReference;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): MemberReference;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): MemberReference;
+    private readonly _containing;
+    get containing(): Expression;
+    withContaining(containing: Expression): MemberReference;
+    private readonly _typeParameters;
+    get typeParameters(): Expression[] | null;
+    withTypeParameters(typeParameters: Expression[] | null): MemberReference;
+    private readonly _reference;
+    get reference(): Identifier;
+    withReference(reference: Identifier): MemberReference;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): MemberReference;
+    private readonly _methodType;
+    get methodType(): JavaType.Method | null;
+    withMethodType(methodType: JavaType.Method | null): MemberReference;
+    private readonly _variableType;
+    get variableType(): JavaType.Variable | null;
+    withVariableType(variableType: JavaType.Variable | null): MemberReference;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly containing: JRightPadded<Expression>;
+        withContaining(containing: JRightPadded<Expression>): MemberReference;
+        readonly typeParameters: JContainer<Expression> | null;
+        withTypeParameters(typeParameters: JContainer<Expression> | null): MemberReference;
+        readonly reference: JLeftPadded<Identifier>;
+        withReference(reference: JLeftPadded<Identifier>): MemberReference;
+    };
+}
+declare const MethodDeclaration_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class MethodDeclaration extends MethodDeclaration_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Annotation[], modifiers: Modifier[], typeParameters: TypeParameters | null, returnTypeExpression: TypeTree | null, name: MethodDeclaration.IdentifierWithAnnotations, parameters: JContainer<Statement>, throws: JContainer<NameTree> | null, body: Block | null, defaultValue: JLeftPadded<Expression> | null, methodType: JavaType.Method | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): MethodDeclaration;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): MethodDeclaration;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): MethodDeclaration;
+    private readonly _leadingAnnotations;
+    get leadingAnnotations(): Annotation[];
+    withLeadingAnnotations(leadingAnnotations: Annotation[]): MethodDeclaration;
+    private readonly _modifiers;
+    get modifiers(): Modifier[];
+    withModifiers(modifiers: Modifier[]): MethodDeclaration;
+    private readonly _typeParameters;
+    private readonly _returnTypeExpression;
+    get returnTypeExpression(): TypeTree | null;
+    withReturnTypeExpression(returnTypeExpression: TypeTree | null): MethodDeclaration;
+    private readonly _name;
+    private readonly _parameters;
+    get parameters(): Statement[];
+    withParameters(parameters: Statement[]): MethodDeclaration;
+    private readonly _throws;
+    get throws(): NameTree[] | null;
+    withThrows(throws: NameTree[] | null): MethodDeclaration;
+    private readonly _body;
+    get body(): Block | null;
+    withBody(body: Block | null): MethodDeclaration;
+    private readonly _defaultValue;
+    get defaultValue(): Expression | null;
+    withDefaultValue(defaultValue: Expression | null): MethodDeclaration;
+    private readonly _methodType;
+    get methodType(): JavaType.Method | null;
+    withMethodType(methodType: JavaType.Method | null): MethodDeclaration;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): MethodDeclaration;
+    get padding(): {
+        readonly typeParameters: TypeParameters | null;
+        withTypeParameters(typeParameters: TypeParameters | null): MethodDeclaration;
+        readonly name: MethodDeclaration.IdentifierWithAnnotations;
+        withName(name: MethodDeclaration.IdentifierWithAnnotations): MethodDeclaration;
+        readonly parameters: JContainer<Statement>;
+        withParameters(parameters: JContainer<Statement>): MethodDeclaration;
+        readonly throws: JContainer<NameTree> | null;
+        withThrows(throws: JContainer<NameTree> | null): MethodDeclaration;
+        readonly defaultValue: JLeftPadded<Expression> | null;
+        withDefaultValue(defaultValue: JLeftPadded<Expression> | null): MethodDeclaration;
+    };
+    get annotations(): {
+        readonly typeParameters: TypeParameters | null;
+        withTypeParameters(typeParameters: TypeParameters | null): MethodDeclaration;
+        readonly name: MethodDeclaration.IdentifierWithAnnotations;
+        withName(name: MethodDeclaration.IdentifierWithAnnotations): MethodDeclaration;
+        readonly parameters: JContainer<Statement>;
+        withParameters(parameters: JContainer<Statement>): MethodDeclaration;
+        readonly throws: JContainer<NameTree> | null;
+        withThrows(throws: JContainer<NameTree> | null): MethodDeclaration;
+        readonly defaultValue: JLeftPadded<Expression> | null;
+        withDefaultValue(defaultValue: JLeftPadded<Expression> | null): MethodDeclaration;
+    };
+}
+export declare namespace MethodDeclaration {
+    class IdentifierWithAnnotations {
+        constructor(identifier: Identifier, annotations: Annotation[]);
+        private readonly _identifier;
+        get identifier(): Identifier;
+        withIdentifier(identifier: Identifier): MethodDeclaration.IdentifierWithAnnotations;
+        private readonly _annotations;
+        get annotations(): Annotation[];
+        withAnnotations(annotations: Annotation[]): MethodDeclaration.IdentifierWithAnnotations;
+    }
+}
+declare const MethodInvocation_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class MethodInvocation extends MethodInvocation_base implements Statement, TypedTree, MethodCall {
+    constructor(id: UUID, prefix: Space, markers: Markers, select: JRightPadded<Expression> | null, typeParameters: JContainer<Expression> | null, name: Identifier, _arguments: JContainer<Expression>, methodType: JavaType.Method | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): MethodInvocation;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): MethodInvocation;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): MethodInvocation;
+    private readonly _select;
+    get select(): Expression | null;
+    withSelect(select: Expression | null): MethodInvocation;
+    private readonly _typeParameters;
+    get typeParameters(): Expression[] | null;
+    withTypeParameters(typeParameters: Expression[] | null): MethodInvocation;
+    private readonly _name;
+    get name(): Identifier;
+    withName(name: Identifier): MethodInvocation;
+    private readonly _arguments;
+    get arguments(): Expression[];
+    withArguments(_arguments: Expression[]): MethodInvocation;
+    private readonly _methodType;
+    get methodType(): JavaType.Method | null;
+    withMethodType(methodType: JavaType.Method | null): MethodInvocation;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): MethodInvocation;
+    get padding(): {
+        readonly select: JRightPadded<Expression> | null;
+        withSelect(select: JRightPadded<Expression> | null): MethodInvocation;
+        readonly typeParameters: JContainer<Expression> | null;
+        withTypeParameters(typeParameters: JContainer<Expression> | null): MethodInvocation;
+        readonly arguments: JContainer<Expression>;
+        withArguments(_arguments: JContainer<Expression>): MethodInvocation;
+    };
+}
+declare const Modifier_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Modifier extends Modifier_base {
+    constructor(id: UUID, prefix: Space, markers: Markers, keyword: string | null, _type: Modifier.Type, annotations: Annotation[]);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Modifier;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Modifier;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Modifier;
+    private readonly _keyword;
+    get keyword(): string | null;
+    withKeyword(keyword: string | null): Modifier;
+    private readonly _type;
+    get type(): Modifier.Type;
+    withType(_type: Modifier.Type): Modifier;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): Modifier;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+export declare namespace Modifier {
+    enum Type {
+        Default = 0,
+        Public = 1,
+        Protected = 2,
+        Private = 3,
+        Abstract = 4,
+        Static = 5,
+        Final = 6,
+        Sealed = 7,
+        NonSealed = 8,
+        Transient = 9,
+        Volatile = 10,
+        Synchronized = 11,
+        Native = 12,
+        Strictfp = 13,
+        Async = 14,
+        Reified = 15,
+        Inline = 16,
+        LanguageExtension = 17
+    }
+}
+declare const MultiCatch_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class MultiCatch extends MultiCatch_base implements TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, alternatives: JRightPadded<NameTree>[]);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): MultiCatch;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): MultiCatch;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): MultiCatch;
+    private readonly _alternatives;
+    get alternatives(): NameTree[];
+    withAlternatives(alternatives: NameTree[]): MultiCatch;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): MultiCatch;
+    get padding(): {
+        readonly alternatives: JRightPadded<NameTree>[];
+        withAlternatives(alternatives: JRightPadded<NameTree>[]): MultiCatch;
+    };
+}
+declare const NewArray_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class NewArray extends NewArray_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, typeExpression: TypeTree | null, dimensions: ArrayDimension[], initializer: JContainer<Expression> | null, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): NewArray;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): NewArray;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): NewArray;
+    private readonly _typeExpression;
+    get typeExpression(): TypeTree | null;
+    withTypeExpression(typeExpression: TypeTree | null): NewArray;
+    private readonly _dimensions;
+    get dimensions(): ArrayDimension[];
+    withDimensions(dimensions: ArrayDimension[]): NewArray;
+    private readonly _initializer;
+    get initializer(): Expression[] | null;
+    withInitializer(initializer: Expression[] | null): NewArray;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): NewArray;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly initializer: JContainer<Expression> | null;
+        withInitializer(initializer: JContainer<Expression> | null): NewArray;
+    };
+}
+declare const ArrayDimension_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ArrayDimension extends ArrayDimension_base {
+    constructor(id: UUID, prefix: Space, markers: Markers, index: JRightPadded<Expression>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ArrayDimension;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ArrayDimension;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ArrayDimension;
+    private readonly _index;
+    get index(): Expression;
+    withIndex(index: Expression): ArrayDimension;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly index: JRightPadded<Expression>;
+        withIndex(index: JRightPadded<Expression>): ArrayDimension;
+    };
+}
+declare const NewClass_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class NewClass extends NewClass_base implements Statement, TypedTree, MethodCall {
+    constructor(id: UUID, prefix: Space, markers: Markers, enclosing: JRightPadded<Expression> | null, _new: Space, clazz: TypeTree | null, _arguments: JContainer<Expression>, body: Block | null, constructorType: JavaType.Method | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): NewClass;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): NewClass;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): NewClass;
+    private readonly _enclosing;
+    get enclosing(): Expression | null;
+    withEnclosing(enclosing: Expression | null): NewClass;
+    private readonly _new;
+    get new(): Space;
+    withNew(_new: Space): NewClass;
+    private readonly _clazz;
+    get clazz(): TypeTree | null;
+    withClazz(clazz: TypeTree | null): NewClass;
+    private readonly _arguments;
+    get arguments(): Expression[];
+    withArguments(_arguments: Expression[]): NewClass;
+    private readonly _body;
+    get body(): Block | null;
+    withBody(body: Block | null): NewClass;
+    private readonly _constructorType;
+    get constructorType(): JavaType.Method | null;
+    withConstructorType(constructorType: JavaType.Method | null): NewClass;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): NewClass;
+    get padding(): {
+        readonly enclosing: JRightPadded<Expression> | null;
+        withEnclosing(enclosing: JRightPadded<Expression> | null): NewClass;
+        readonly arguments: JContainer<Expression>;
+        withArguments(_arguments: JContainer<Expression>): NewClass;
+    };
+}
+declare const NullableType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class NullableType extends NullableType_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], typeTree: JRightPadded<TypeTree>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): NullableType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): NullableType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): NullableType;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): NullableType;
+    private readonly _typeTree;
+    get typeTree(): TypeTree;
+    withTypeTree(typeTree: TypeTree): NullableType;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): NullableType;
+    get padding(): {
+        readonly typeTree: JRightPadded<TypeTree>;
+        withTypeTree(typeTree: JRightPadded<TypeTree>): NullableType;
+    };
+}
+declare const Package_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Package extends Package_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: Expression, annotations: Annotation[]);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Package;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Package;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Package;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): Package;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): Package;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const ParameterizedType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ParameterizedType extends ParameterizedType_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, clazz: NameTree, typeParameters: JContainer<Expression> | null, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ParameterizedType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ParameterizedType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ParameterizedType;
+    private readonly _clazz;
+    get clazz(): NameTree;
+    withClazz(clazz: NameTree): ParameterizedType;
+    private readonly _typeParameters;
+    get typeParameters(): Expression[] | null;
+    withTypeParameters(typeParameters: Expression[] | null): ParameterizedType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ParameterizedType;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly typeParameters: JContainer<Expression> | null;
+        withTypeParameters(typeParameters: JContainer<Expression> | null): ParameterizedType;
+    };
+}
+declare const Parentheses_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Parentheses<J2 extends J> extends Parentheses_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, tree: JRightPadded<J2>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Parentheses<J2>;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Parentheses<J2>;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Parentheses<J2>;
+    private readonly _tree;
+    get tree(): J2;
+    withTree(tree: J2): Parentheses<J2>;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Parentheses<J2>;
+    get padding(): {
+        readonly tree: JRightPadded<J2>;
+        withTree(tree: JRightPadded<J2>): Parentheses<J2>;
+    };
+}
+declare const ControlParentheses_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class ControlParentheses<J2 extends J> extends ControlParentheses_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, tree: JRightPadded<J2>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ControlParentheses<J2>;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ControlParentheses<J2>;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ControlParentheses<J2>;
+    private readonly _tree;
+    get tree(): J2;
+    withTree(tree: J2): ControlParentheses<J2>;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): ControlParentheses<J2>;
+    get padding(): {
+        readonly tree: JRightPadded<J2>;
+        withTree(tree: JRightPadded<J2>): ControlParentheses<J2>;
+    };
+}
+declare const Primitive_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Primitive extends Primitive_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, _type: JavaType.Primitive);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Primitive;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Primitive;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Primitive;
+    private readonly _type;
+    get type(): JavaType.Primitive;
+    withType(_type: JavaType.Primitive): Primitive;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Return_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Return extends Return_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: Expression | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Return;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Return;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Return;
+    private readonly _expression;
+    get expression(): Expression | null;
+    withExpression(expression: Expression | null): Return;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Switch_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Switch extends Switch_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, selector: ControlParentheses<Expression>, cases: Block);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Switch;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Switch;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Switch;
+    private readonly _selector;
+    get selector(): ControlParentheses<Expression>;
+    withSelector(selector: ControlParentheses<Expression>): Switch;
+    private readonly _cases;
+    get cases(): Block;
+    withCases(cases: Block): Switch;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const SwitchExpression_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class SwitchExpression extends SwitchExpression_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, selector: ControlParentheses<Expression>, cases: Block);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): SwitchExpression;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): SwitchExpression;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): SwitchExpression;
+    private readonly _selector;
+    get selector(): ControlParentheses<Expression>;
+    withSelector(selector: ControlParentheses<Expression>): SwitchExpression;
+    private readonly _cases;
+    get cases(): Block;
+    withCases(cases: Block): SwitchExpression;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): SwitchExpression;
+}
+declare const Synchronized_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Synchronized extends Synchronized_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, lock: ControlParentheses<Expression>, body: Block);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Synchronized;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Synchronized;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Synchronized;
+    private readonly _lock;
+    get lock(): ControlParentheses<Expression>;
+    withLock(lock: ControlParentheses<Expression>): Synchronized;
+    private readonly _body;
+    get body(): Block;
+    withBody(body: Block): Synchronized;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Ternary_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Ternary extends Ternary_base implements Expression, Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, condition: Expression, truePart: JLeftPadded<Expression>, falsePart: JLeftPadded<Expression>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Ternary;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Ternary;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Ternary;
+    private readonly _condition;
+    get condition(): Expression;
+    withCondition(condition: Expression): Ternary;
+    private readonly _truePart;
+    get truePart(): Expression;
+    withTruePart(truePart: Expression): Ternary;
+    private readonly _falsePart;
+    get falsePart(): Expression;
+    withFalsePart(falsePart: Expression): Ternary;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Ternary;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly truePart: JLeftPadded<Expression>;
+        withTruePart(truePart: JLeftPadded<Expression>): Ternary;
+        readonly falsePart: JLeftPadded<Expression>;
+        withFalsePart(falsePart: JLeftPadded<Expression>): Ternary;
+    };
+}
+declare const Throw_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Throw extends Throw_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, exception: Expression);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Throw;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Throw;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Throw;
+    private readonly _exception;
+    get exception(): Expression;
+    withException(exception: Expression): Throw;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Try_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Try extends Try_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, resources: JContainer<Try.Resource> | null, body: Block, catches: Try.Catch[], _finally: JLeftPadded<Block> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Try;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Try;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Try;
+    private readonly _resources;
+    get resources(): Try.Resource[] | null;
+    withResources(resources: Try.Resource[] | null): Try;
+    private readonly _body;
+    get body(): Block;
+    withBody(body: Block): Try;
+    private readonly _catches;
+    get catches(): Try.Catch[];
+    withCatches(catches: Try.Catch[]): Try;
+    private readonly _finally;
+    get finally(): Block | null;
+    withFinally(_finally: Block | null): Try;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly resources: JContainer<Try.Resource> | null;
+        withResources(resources: JContainer<Try.Resource> | null): Try;
+        readonly finally: JLeftPadded<Block> | null;
+        withFinally(_finally: JLeftPadded<Block> | null): Try;
+    };
+}
+export declare namespace Try {
+    const Resource_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Resource extends Resource_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, variableDeclarations: TypedTree, terminatedWithSemicolon: boolean);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): Try.Resource;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): Try.Resource;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): Try.Resource;
+        private readonly _variableDeclarations;
+        get variableDeclarations(): TypedTree;
+        withVariableDeclarations(variableDeclarations: TypedTree): Try.Resource;
+        private readonly _terminatedWithSemicolon;
+        get terminatedWithSemicolon(): boolean;
+        withTerminatedWithSemicolon(terminatedWithSemicolon: boolean): Try.Resource;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    }
+    const Catch_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Catch extends Catch_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, parameter: ControlParentheses<VariableDeclarations>, body: Block);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): Try.Catch;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): Try.Catch;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): Try.Catch;
+        private readonly _parameter;
+        get parameter(): ControlParentheses<VariableDeclarations>;
+        withParameter(parameter: ControlParentheses<VariableDeclarations>): Try.Catch;
+        private readonly _body;
+        get body(): Block;
+        withBody(body: Block): Try.Catch;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    }
+    export {};
+}
+declare const TypeCast_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class TypeCast extends TypeCast_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, clazz: ControlParentheses<TypeTree>, expression: Expression);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeCast;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeCast;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeCast;
+    private readonly _clazz;
+    get clazz(): ControlParentheses<TypeTree>;
+    withClazz(clazz: ControlParentheses<TypeTree>): TypeCast;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): TypeCast;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): TypeCast;
+}
+declare const TypeParameter_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class TypeParameter extends TypeParameter_base {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], modifiers: Modifier[], name: Expression, bounds: JContainer<TypeTree> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeParameter;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeParameter;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeParameter;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): TypeParameter;
+    private readonly _modifiers;
+    get modifiers(): Modifier[];
+    withModifiers(modifiers: Modifier[]): TypeParameter;
+    private readonly _name;
+    get name(): Expression;
+    withName(name: Expression): TypeParameter;
+    private readonly _bounds;
+    get bounds(): TypeTree[] | null;
+    withBounds(bounds: TypeTree[] | null): TypeParameter;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly bounds: JContainer<TypeTree> | null;
+        withBounds(bounds: JContainer<TypeTree> | null): TypeParameter;
+    };
+}
+declare const TypeParameters_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class TypeParameters extends TypeParameters_base {
+    constructor(id: UUID, prefix: Space, markers: Markers, annotations: Annotation[], typeParameters: JRightPadded<TypeParameter>[]);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeParameters;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeParameters;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeParameters;
+    private readonly _annotations;
+    get annotations(): Annotation[];
+    withAnnotations(annotations: Annotation[]): TypeParameters;
+    private readonly _typeParameters;
+    get typeParameters(): TypeParameter[];
+    withTypeParameters(typeParameters: TypeParameter[]): TypeParameters;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly typeParameters: JRightPadded<TypeParameter>[];
+        withTypeParameters(typeParameters: JRightPadded<TypeParameter>[]): TypeParameters;
+    };
+}
+declare const Unary_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Unary extends Unary_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, operator: JLeftPadded<Unary.Type>, expression: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Unary;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Unary;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Unary;
+    private readonly _operator;
+    get operator(): Unary.Type;
+    withOperator(operator: Unary.Type): Unary;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): Unary;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Unary;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly operator: JLeftPadded<Unary.Type>;
+        withOperator(operator: JLeftPadded<Unary.Type>): Unary;
+    };
+}
+export declare namespace Unary {
+    enum Type {
+        PreIncrement = 0,
+        PreDecrement = 1,
+        PostIncrement = 2,
+        PostDecrement = 3,
+        Positive = 4,
+        Negative = 5,
+        Complement = 6,
+        Not = 7
+    }
+}
+declare const VariableDeclarations_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class VariableDeclarations extends VariableDeclarations_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Annotation[], modifiers: Modifier[], typeExpression: TypeTree | null, varargs: Space | null, dimensionsBeforeName: JLeftPadded<Space>[], variables: JRightPadded<VariableDeclarations.NamedVariable>[]);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): VariableDeclarations;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): VariableDeclarations;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): VariableDeclarations;
+    private readonly _leadingAnnotations;
+    get leadingAnnotations(): Annotation[];
+    withLeadingAnnotations(leadingAnnotations: Annotation[]): VariableDeclarations;
+    private readonly _modifiers;
+    get modifiers(): Modifier[];
+    withModifiers(modifiers: Modifier[]): VariableDeclarations;
+    private readonly _typeExpression;
+    get typeExpression(): TypeTree | null;
+    withTypeExpression(typeExpression: TypeTree | null): VariableDeclarations;
+    private readonly _varargs;
+    get varargs(): Space | null;
+    withVarargs(varargs: Space | null): VariableDeclarations;
+    private readonly _dimensionsBeforeName;
+    get dimensionsBeforeName(): JLeftPadded<Space>[];
+    withDimensionsBeforeName(dimensionsBeforeName: JLeftPadded<Space>[]): VariableDeclarations;
+    private readonly _variables;
+    get variables(): VariableDeclarations.NamedVariable[];
+    withVariables(variables: VariableDeclarations.NamedVariable[]): VariableDeclarations;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): VariableDeclarations;
+    get padding(): {
+        readonly variables: JRightPadded<VariableDeclarations.NamedVariable>[];
+        withVariables(variables: JRightPadded<VariableDeclarations.NamedVariable>[]): VariableDeclarations;
+    };
+}
+export declare namespace VariableDeclarations {
+    const NamedVariable_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class NamedVariable extends NamedVariable_base implements NameTree {
+        constructor(id: UUID, prefix: Space, markers: Markers, name: Identifier, dimensionsAfterName: JLeftPadded<Space>[], initializer: JLeftPadded<Expression> | null, variableType: JavaType.Variable | null);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): VariableDeclarations.NamedVariable;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): VariableDeclarations.NamedVariable;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): VariableDeclarations.NamedVariable;
+        private readonly _name;
+        get name(): Identifier;
+        withName(name: Identifier): VariableDeclarations.NamedVariable;
+        private readonly _dimensionsAfterName;
+        get dimensionsAfterName(): JLeftPadded<Space>[];
+        withDimensionsAfterName(dimensionsAfterName: JLeftPadded<Space>[]): VariableDeclarations.NamedVariable;
+        private readonly _initializer;
+        get initializer(): Expression | null;
+        withInitializer(initializer: Expression | null): VariableDeclarations.NamedVariable;
+        private readonly _variableType;
+        get variableType(): JavaType.Variable | null;
+        withVariableType(variableType: JavaType.Variable | null): VariableDeclarations.NamedVariable;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+        get type(): JavaType | null;
+        withType(type: JavaType): VariableDeclarations.NamedVariable;
+        get padding(): {
+            readonly initializer: JLeftPadded<Expression> | null;
+            withInitializer(initializer: JLeftPadded<Expression> | null): VariableDeclarations.NamedVariable;
+        };
+    }
+    export {};
+}
+declare const WhileLoop_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class WhileLoop extends WhileLoop_base implements Loop {
+    constructor(id: UUID, prefix: Space, markers: Markers, condition: ControlParentheses<Expression>, body: JRightPadded<Statement>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): WhileLoop;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): WhileLoop;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): WhileLoop;
+    private readonly _condition;
+    get condition(): ControlParentheses<Expression>;
+    withCondition(condition: ControlParentheses<Expression>): WhileLoop;
+    private readonly _body;
+    get body(): Statement;
+    withBody(body: Statement): WhileLoop;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly body: JRightPadded<Statement>;
+        withBody(body: JRightPadded<Statement>): WhileLoop;
+    };
+}
+declare const Wildcard_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Wildcard extends Wildcard_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, bound: JLeftPadded<Wildcard.Bound> | null, boundedType: NameTree | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Wildcard;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Wildcard;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Wildcard;
+    private readonly _bound;
+    get bound(): Wildcard.Bound | null;
+    withBound(bound: Wildcard.Bound | null): Wildcard;
+    private readonly _boundedType;
+    get boundedType(): NameTree | null;
+    withBoundedType(boundedType: NameTree | null): Wildcard;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Wildcard;
+    get padding(): {
+        readonly bound: JLeftPadded<Wildcard.Bound> | null;
+        withBound(bound: JLeftPadded<Wildcard.Bound> | null): Wildcard;
+    };
+}
+export declare namespace Wildcard {
+    enum Bound {
+        Extends = 0,
+        Super = 1
+    }
+}
+declare const Yield_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Yield extends Yield_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, implicit: boolean, value: Expression);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Yield;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Yield;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Yield;
+    private readonly _implicit;
+    get implicit(): boolean;
+    withImplicit(implicit: boolean): Yield;
+    private readonly _value;
+    get value(): Expression;
+    withValue(value: Expression): Yield;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+}
+declare const Unknown_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): J;
+    readonly id: Uint8Array;
+    withId(id: UUID): J;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): J;
+    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: JavaVisitor<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;
+}) & ObjectConstructor;
+export declare class Unknown extends Unknown_base implements Statement, Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, source: Unknown.Source);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Unknown;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Unknown;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Unknown;
+    private readonly _source;
+    get source(): Unknown.Source;
+    withSource(source: Unknown.Source): Unknown;
+    acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Unknown;
+}
+export declare namespace Unknown {
+    const Source_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): J;
+        readonly id: Uint8Array;
+        withId(id: UUID): J;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): J;
+        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: JavaVisitor<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;
+    }) & ObjectConstructor;
+    export class Source extends Source_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, text: string);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): Unknown.Source;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): Unknown.Source;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): Unknown.Source;
+        private readonly _text;
+        get text(): string;
+        withText(text: string): Unknown.Source;
+        acceptJava<P>(v: JavaVisitor<P>, p: P): J | null;
+    }
+    export {};
+}
+export {};
+//# sourceMappingURL=tree.d.ts.map