@openrewrite/rewrite 0.18.0

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

@@ -0,0 +1,1173 @@
+import { JS } from "./support_types";
+import { JavaScriptVisitor } from "../visitor";
+import { Checksum, Cursor, FileAttributes, Markers, PrintOutputCapture, SourceFile, Tree, TreeVisitor, UUID } from "../../core";
+import { Expression, J, JavaSourceFile, JavaType, JContainer, JLeftPadded, JRightPadded, NameTree, Space, Statement, TypedTree, TypeTree } from "../../java/tree";
+import * as Java from "../../java/tree";
+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): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class 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, imports: JRightPadded<Java.Import>[], statements: JRightPadded<Statement>[], 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 _imports;
+    get imports(): Java.Import[];
+    withImports(imports: Java.Import[]): CompilationUnit;
+    private readonly _statements;
+    get statements(): Statement[];
+    withStatements(statements: Statement[]): CompilationUnit;
+    private readonly _eof;
+    get eof(): Space;
+    withEof(eof: Space): CompilationUnit;
+    printer<P>(cursor: Cursor): TreeVisitor<Tree, PrintOutputCapture<P>>;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly imports: JRightPadded<Java.Import>[];
+        withImports(imports: JRightPadded<Java.Import>[]): CompilationUnit;
+        readonly statements: JRightPadded<Statement>[];
+        withStatements(statements: JRightPadded<Statement>[]): CompilationUnit;
+    };
+}
+declare const Alias_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Alias extends Alias_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, propertyName: JRightPadded<Java.Identifier>, alias: Java.Identifier);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Alias;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Alias;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Alias;
+    private readonly _propertyName;
+    get propertyName(): Java.Identifier;
+    withPropertyName(propertyName: Java.Identifier): Alias;
+    private readonly _alias;
+    get alias(): Java.Identifier;
+    withAlias(alias: Java.Identifier): Alias;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Alias;
+    get padding(): {
+        readonly propertyName: JRightPadded<Java.Identifier>;
+        withPropertyName(propertyName: JRightPadded<Java.Identifier>): Alias;
+    };
+}
+declare const ArrowFunction_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class ArrowFunction extends ArrowFunction_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], parameters: Java.Lambda.Parameters, returnTypeExpression: TypeTree | null, arrow: Space, body: J, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ArrowFunction;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ArrowFunction;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ArrowFunction;
+    private readonly _leadingAnnotations;
+    get leadingAnnotations(): Java.Annotation[];
+    withLeadingAnnotations(leadingAnnotations: Java.Annotation[]): ArrowFunction;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): ArrowFunction;
+    private readonly _parameters;
+    get parameters(): Java.Lambda.Parameters;
+    withParameters(parameters: Java.Lambda.Parameters): ArrowFunction;
+    private readonly _returnTypeExpression;
+    get returnTypeExpression(): TypeTree | null;
+    withReturnTypeExpression(returnTypeExpression: TypeTree | null): ArrowFunction;
+    private readonly _arrow;
+    get arrow(): Space;
+    withArrow(arrow: Space): ArrowFunction;
+    private readonly _body;
+    get body(): J;
+    withBody(body: J): ArrowFunction;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ArrowFunction;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
+declare const Await_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Await extends Await_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Await;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Await;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Await;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): Await;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Await;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
+declare const DefaultType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class DefaultType extends DefaultType_base implements Expression, TypedTree, NameTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, left: Expression, beforeEquals: Space, right: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): DefaultType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): DefaultType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): DefaultType;
+    private readonly _left;
+    get left(): Expression;
+    withLeft(left: Expression): DefaultType;
+    private readonly _beforeEquals;
+    get beforeEquals(): Space;
+    withBeforeEquals(beforeEquals: Space): DefaultType;
+    private readonly _right;
+    get right(): Expression;
+    withRight(right: Expression): DefaultType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): DefaultType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
+declare const Delete_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Delete extends Delete_base implements Expression, Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Delete;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Delete;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Delete;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): Delete;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Delete;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
+declare const Export_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Export extends Export_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, exports: JContainer<Expression> | null, _from: Space | null, target: Java.Literal | null, initializer: JLeftPadded<Expression> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Export;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Export;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Export;
+    private readonly _exports;
+    get exports(): Expression[] | null;
+    withExports(exports: Expression[] | null): Export;
+    private readonly _from;
+    get from(): Space | null;
+    withFrom(_from: Space | null): Export;
+    private readonly _target;
+    get target(): Java.Literal | null;
+    withTarget(target: Java.Literal | null): Export;
+    private readonly _initializer;
+    get initializer(): Expression | null;
+    withInitializer(initializer: Expression | null): Export;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly exports: JContainer<Expression> | null;
+        withExports(exports: JContainer<Expression> | null): Export;
+        readonly initializer: JLeftPadded<Expression> | null;
+        withInitializer(initializer: JLeftPadded<Expression> | null): Export;
+    };
+}
+declare const FunctionType_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class FunctionType extends FunctionType_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, parameters: JContainer<Statement>, arrow: Space, returnType: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): FunctionType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): FunctionType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): FunctionType;
+    private readonly _parameters;
+    get parameters(): Statement[];
+    withParameters(parameters: Statement[]): FunctionType;
+    private readonly _arrow;
+    get arrow(): Space;
+    withArrow(arrow: Space): FunctionType;
+    private readonly _returnType;
+    get returnType(): Expression;
+    withReturnType(returnType: Expression): FunctionType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): FunctionType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly parameters: JContainer<Statement>;
+        withParameters(parameters: JContainer<Statement>): FunctionType;
+    };
+}
+declare const JsImport_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JsImport extends JsImport_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, name: JRightPadded<Java.Identifier> | null, imports: JContainer<Expression> | null, _from: Space | null, target: Java.Literal | null, initializer: JLeftPadded<Expression> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JsImport;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JsImport;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JsImport;
+    private readonly _name;
+    get name(): Java.Identifier | null;
+    withName(name: Java.Identifier | null): JsImport;
+    private readonly _imports;
+    get imports(): Expression[] | null;
+    withImports(imports: Expression[] | null): JsImport;
+    private readonly _from;
+    get from(): Space | null;
+    withFrom(_from: Space | null): JsImport;
+    private readonly _target;
+    get target(): Java.Literal | null;
+    withTarget(target: Java.Literal | null): JsImport;
+    private readonly _initializer;
+    get initializer(): Expression | null;
+    withInitializer(initializer: Expression | null): JsImport;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly name: JRightPadded<Java.Identifier> | null;
+        withName(name: JRightPadded<Java.Identifier> | null): JsImport;
+        readonly imports: JContainer<Expression> | null;
+        withImports(imports: JContainer<Expression> | null): JsImport;
+        readonly initializer: JLeftPadded<Expression> | null;
+        withInitializer(initializer: JLeftPadded<Expression> | null): JsImport;
+    };
+}
+declare const JsBinary_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class JsBinary extends JsBinary_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, left: Expression, operator: JLeftPadded<JsBinary.Type>, right: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JsBinary;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JsBinary;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JsBinary;
+    private readonly _left;
+    get left(): Expression;
+    withLeft(left: Expression): JsBinary;
+    private readonly _operator;
+    get operator(): JsBinary.Type;
+    withOperator(operator: JsBinary.Type): JsBinary;
+    private readonly _right;
+    get right(): Expression;
+    withRight(right: Expression): JsBinary;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): JsBinary;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly operator: JLeftPadded<JsBinary.Type>;
+        withOperator(operator: JLeftPadded<JsBinary.Type>): JsBinary;
+    };
+}
+export declare namespace JsBinary {
+    enum Type {
+        As = 0,
+        IdentityEquals = 1,
+        IdentityNotEquals = 2,
+        In = 3
+    }
+}
+declare const ObjectBindingDeclarations_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class ObjectBindingDeclarations extends ObjectBindingDeclarations_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], typeExpression: TypeTree | null, bindings: JContainer<ObjectBindingDeclarations.Binding>, initializer: JLeftPadded<Expression> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ObjectBindingDeclarations;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ObjectBindingDeclarations;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ObjectBindingDeclarations;
+    private readonly _leadingAnnotations;
+    get leadingAnnotations(): Java.Annotation[];
+    withLeadingAnnotations(leadingAnnotations: Java.Annotation[]): ObjectBindingDeclarations;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): ObjectBindingDeclarations;
+    private readonly _typeExpression;
+    get typeExpression(): TypeTree | null;
+    withTypeExpression(typeExpression: TypeTree | null): ObjectBindingDeclarations;
+    private readonly _bindings;
+    get bindings(): ObjectBindingDeclarations.Binding[];
+    withBindings(bindings: ObjectBindingDeclarations.Binding[]): ObjectBindingDeclarations;
+    private readonly _initializer;
+    get initializer(): Expression | null;
+    withInitializer(initializer: Expression | null): ObjectBindingDeclarations;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): ObjectBindingDeclarations;
+    get padding(): {
+        readonly bindings: JContainer<ObjectBindingDeclarations.Binding>;
+        withBindings(bindings: JContainer<ObjectBindingDeclarations.Binding>): ObjectBindingDeclarations;
+        readonly initializer: JLeftPadded<Expression> | null;
+        withInitializer(initializer: JLeftPadded<Expression> | null): ObjectBindingDeclarations;
+    };
+}
+export declare namespace ObjectBindingDeclarations {
+    const Binding_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): JS;
+        readonly id: Uint8Array;
+        withId(id: UUID): JS;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): JS;
+        isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+        accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+        acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }) & {
+        isTree: boolean;
+        isJava: boolean;
+        isJavaScript: boolean;
+    }) & ObjectConstructor;
+    export class Binding extends Binding_base implements NameTree {
+        constructor(id: UUID, prefix: Space, markers: Markers, propertyName: JRightPadded<Java.Identifier> | null, name: Java.Identifier, dimensionsAfterName: JLeftPadded<Space>[], afterVararg: Space | null, initializer: JLeftPadded<Expression> | null, variableType: JavaType.Variable | null);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): ObjectBindingDeclarations.Binding;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): ObjectBindingDeclarations.Binding;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): ObjectBindingDeclarations.Binding;
+        private readonly _propertyName;
+        get propertyName(): Java.Identifier | null;
+        withPropertyName(propertyName: Java.Identifier | null): ObjectBindingDeclarations.Binding;
+        private readonly _name;
+        get name(): Java.Identifier;
+        withName(name: Java.Identifier): ObjectBindingDeclarations.Binding;
+        private readonly _dimensionsAfterName;
+        get dimensionsAfterName(): JLeftPadded<Space>[];
+        withDimensionsAfterName(dimensionsAfterName: JLeftPadded<Space>[]): ObjectBindingDeclarations.Binding;
+        private readonly _afterVararg;
+        get afterVararg(): Space | null;
+        withAfterVararg(afterVararg: Space | null): ObjectBindingDeclarations.Binding;
+        private readonly _initializer;
+        get initializer(): Expression | null;
+        withInitializer(initializer: Expression | null): ObjectBindingDeclarations.Binding;
+        private readonly _variableType;
+        get variableType(): JavaType.Variable | null;
+        withVariableType(variableType: JavaType.Variable | null): ObjectBindingDeclarations.Binding;
+        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+        get type(): JavaType | null;
+        withType(type: JavaType): ObjectBindingDeclarations.Binding;
+        get padding(): {
+            readonly propertyName: JRightPadded<Java.Identifier> | null;
+            withPropertyName(propertyName: JRightPadded<Java.Identifier> | null): ObjectBindingDeclarations.Binding;
+            readonly initializer: JLeftPadded<Expression> | null;
+            withInitializer(initializer: JLeftPadded<Expression> | null): ObjectBindingDeclarations.Binding;
+        };
+    }
+    export {};
+}
+declare const PropertyAssignment_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class PropertyAssignment extends PropertyAssignment_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, name: JRightPadded<Expression>, initializer: Expression);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): PropertyAssignment;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): PropertyAssignment;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): PropertyAssignment;
+    private readonly _name;
+    get name(): Expression;
+    withName(name: Expression): PropertyAssignment;
+    private readonly _initializer;
+    get initializer(): Expression;
+    withInitializer(initializer: Expression): PropertyAssignment;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): PropertyAssignment;
+    get padding(): {
+        readonly name: JRightPadded<Expression>;
+        withName(name: JRightPadded<Expression>): PropertyAssignment;
+    };
+}
+declare const TemplateExpression_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class TemplateExpression extends TemplateExpression_base implements Statement, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, delimiter: string, tag: JRightPadded<Expression> | null, strings: J[], _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TemplateExpression;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TemplateExpression;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TemplateExpression;
+    private readonly _delimiter;
+    get delimiter(): string;
+    withDelimiter(delimiter: string): TemplateExpression;
+    private readonly _tag;
+    get tag(): Expression | null;
+    withTag(tag: Expression | null): TemplateExpression;
+    private readonly _strings;
+    get strings(): J[];
+    withStrings(strings: J[]): TemplateExpression;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TemplateExpression;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly tag: JRightPadded<Expression> | null;
+        withTag(tag: JRightPadded<Expression> | null): TemplateExpression;
+    };
+}
+export declare namespace TemplateExpression {
+    const Value_base: ((abstract new (...args: any[]) => {
+        readonly prefix: Space;
+        withPrefix(prefix: Space): JS;
+        readonly id: Uint8Array;
+        withId(id: UUID): JS;
+        readonly markers: Markers;
+        withMarkers(markers: Markers): JS;
+        isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+        accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+        acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }) & {
+        isTree: boolean;
+        isJava: boolean;
+        isJavaScript: boolean;
+    }) & ObjectConstructor;
+    export class Value extends Value_base {
+        constructor(id: UUID, prefix: Space, markers: Markers, tree: J, after: Space, enclosedInBraces: boolean);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): TemplateExpression.Value;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): TemplateExpression.Value;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): TemplateExpression.Value;
+        private readonly _tree;
+        get tree(): J;
+        withTree(tree: J): TemplateExpression.Value;
+        private readonly _after;
+        get after(): Space;
+        withAfter(after: Space): TemplateExpression.Value;
+        private readonly _enclosedInBraces;
+        get enclosedInBraces(): boolean;
+        withEnclosedInBraces(enclosedInBraces: boolean): TemplateExpression.Value;
+        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    }
+    export {};
+}
+declare const Tuple_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Tuple extends Tuple_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, elements: JContainer<J>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Tuple;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Tuple;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Tuple;
+    private readonly _elements;
+    get elements(): J[];
+    withElements(elements: J[]): Tuple;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Tuple;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly elements: JContainer<J>;
+        withElements(elements: JContainer<J>): Tuple;
+    };
+}
+declare const TypeDeclaration_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class TypeDeclaration extends TypeDeclaration_base implements Statement, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, leadingAnnotations: Java.Annotation[], modifiers: Java.Modifier[], name: Java.Identifier, typeParameters: Java.TypeParameters | null, initializer: JLeftPadded<Expression>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeDeclaration;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeDeclaration;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeDeclaration;
+    private readonly _leadingAnnotations;
+    get leadingAnnotations(): Java.Annotation[];
+    withLeadingAnnotations(leadingAnnotations: Java.Annotation[]): TypeDeclaration;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): TypeDeclaration;
+    private readonly _name;
+    get name(): Java.Identifier;
+    withName(name: Java.Identifier): TypeDeclaration;
+    private readonly _typeParameters;
+    get typeParameters(): Java.TypeParameters | null;
+    withTypeParameters(typeParameters: Java.TypeParameters | null): TypeDeclaration;
+    private readonly _initializer;
+    get initializer(): Expression;
+    withInitializer(initializer: Expression): TypeDeclaration;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TypeDeclaration;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly initializer: JLeftPadded<Expression>;
+        withInitializer(initializer: JLeftPadded<Expression>): TypeDeclaration;
+    };
+}
+declare const TypeOf_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class TypeOf extends TypeOf_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeOf;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeOf;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeOf;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): TypeOf;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TypeOf;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
+declare const TypeOperator_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class TypeOperator extends TypeOperator_base implements Expression, TypedTree, NameTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, operator: TypeOperator.Type, expression: JLeftPadded<Expression>);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypeOperator;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypeOperator;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypeOperator;
+    private readonly _operator;
+    get operator(): TypeOperator.Type;
+    withOperator(operator: TypeOperator.Type): TypeOperator;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): TypeOperator;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): TypeOperator;
+    get padding(): {
+        readonly expression: JLeftPadded<Expression>;
+        withExpression(expression: JLeftPadded<Expression>): TypeOperator;
+    };
+}
+export declare namespace TypeOperator {
+    enum Type {
+        ReadOnly = 0,
+        KeyOf = 1
+    }
+}
+declare const Unary_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class 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;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly operator: JLeftPadded<Unary.Type>;
+        withOperator(operator: JLeftPadded<Unary.Type>): Unary;
+    };
+}
+export declare namespace Unary {
+    enum Type {
+        Spread = 0
+    }
+}
+declare const Union_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Union extends Union_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, types: JRightPadded<Expression>[], _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Union;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Union;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Union;
+    private readonly _types;
+    get types(): Expression[];
+    withTypes(types: Expression[]): Union;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): Union;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly types: JRightPadded<Expression>[];
+        withTypes(types: JRightPadded<Expression>[]): Union;
+    };
+}
+declare const Void_base: ((abstract new (...args: any[]) => {
+    readonly prefix: Space;
+    withPrefix(prefix: Space): JS;
+    readonly id: Uint8Array;
+    withId(id: UUID): JS;
+    readonly markers: Markers;
+    withMarkers(markers: Markers): JS;
+    isAcceptable<P>(v: TreeVisitor<Tree, P>, p: P): boolean;
+    accept<R extends Tree, P>(v: TreeVisitor<R, P>, p: P): R | null;
+    acceptJava<P>(v: import("../../java").JavaVisitor<P>, p: P): J | null;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    constructor: Function;
+    toString(): string;
+    toLocaleString(): string;
+    valueOf(): Object;
+    hasOwnProperty(v: PropertyKey): boolean;
+    isPrototypeOf(v: Object): boolean;
+    propertyIsEnumerable(v: PropertyKey): boolean;
+}) & {
+    isTree: boolean;
+    isJava: boolean;
+    isJavaScript: boolean;
+}) & ObjectConstructor;
+export declare class Void extends Void_base implements Expression, Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: Expression);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): Void;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): Void;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): Void;
+    private readonly _expression;
+    get expression(): Expression;
+    withExpression(expression: Expression): Void;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get type(): JavaType | null;
+    withType(type: JavaType): Void;
+}
+export {};
+//# sourceMappingURL=tree.d.ts.map