@openrewrite/rewrite 0.23.0 → 0.24.0

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

@@ -118,7 +118,7 @@ declare const Alias_base: ((abstract new (...args: any[]) => {
     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);
+    constructor(id: UUID, prefix: Space, markers: Markers, propertyName: JRightPadded<Java.Identifier>, alias: Expression);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): Alias;
@@ -132,8 +132,8 @@ export declare class Alias extends Alias_base implements Expression {
     get propertyName(): Java.Identifier;
     withPropertyName(propertyName: Java.Identifier): Alias;
     private readonly _alias;
-    get alias(): Java.Identifier;
-    withAlias(alias: Java.Identifier): Alias;
+    get alias(): Expression;
+    withAlias(alias: Expression): Alias;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get type(): JavaType | null;
     withType(type: JavaType): Alias;
@@ -510,7 +510,7 @@ declare const FunctionType_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class FunctionType extends FunctionType_base implements Expression, TypeTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, constructorType: JRightPadded<boolean>, parameters: JContainer<Statement>, arrow: Space, returnType: Expression, _type: JavaType | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, constructorType: JRightPadded<boolean>, typeParameters: Java.TypeParameters | null, parameters: JContainer<Statement>, arrow: Space, returnType: Expression, _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): FunctionType;
@@ -523,6 +523,9 @@ export declare class FunctionType extends FunctionType_base implements Expressio
     private readonly _constructorType;
     get constructorType(): boolean;
     withConstructorType(constructorType: boolean): FunctionType;
+    private readonly _typeParameters;
+    get typeParameters(): Java.TypeParameters | null;
+    withTypeParameters(typeParameters: Java.TypeParameters | null): FunctionType;
     private readonly _parameters;
     get parameters(): Statement[];
     withParameters(parameters: Statement[]): FunctionType;
@@ -543,6 +546,111 @@ export declare class FunctionType extends FunctionType_base implements Expressio
         withParameters(parameters: JContainer<Statement>): FunctionType;
     };
 }
+declare const InferType_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 InferType extends InferType_base implements TypeTree, Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, typeParameter: JLeftPadded<J>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): InferType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): InferType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): InferType;
+    private readonly _typeParameter;
+    get typeParameter(): J;
+    withTypeParameter(typeParameter: J): InferType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): InferType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly typeParameter: JLeftPadded<J>;
+        withTypeParameter(typeParameter: JLeftPadded<J>): InferType;
+    };
+}
+declare const ImportType_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 ImportType extends ImportType_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, hasTypeof: JRightPadded<boolean>, importArgument: Java.ParenthesizedTypeTree, qualifier: JLeftPadded<Expression> | null, typeArguments: JContainer<Expression> | null, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ImportType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ImportType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ImportType;
+    private readonly _hasTypeof;
+    get hasTypeof(): boolean;
+    withHasTypeof(hasTypeof: boolean): ImportType;
+    private readonly _importArgument;
+    get importArgument(): Java.ParenthesizedTypeTree;
+    withImportArgument(importArgument: Java.ParenthesizedTypeTree): ImportType;
+    private readonly _qualifier;
+    get qualifier(): Expression | null;
+    withQualifier(qualifier: Expression | null): ImportType;
+    private readonly _typeArguments;
+    get typeArguments(): Expression[] | null;
+    withTypeArguments(typeArguments: Expression[] | null): ImportType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ImportType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly hasTypeof: JRightPadded<boolean>;
+        withHasTypeof(hasTypeof: JRightPadded<boolean>): ImportType;
+        readonly qualifier: JLeftPadded<Expression> | null;
+        withQualifier(qualifier: JLeftPadded<Expression> | null): ImportType;
+        readonly typeArguments: JContainer<Expression> | null;
+        withTypeArguments(typeArguments: JContainer<Expression> | null): ImportType;
+    };
+}
 declare const JsImport_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -714,9 +822,52 @@ export declare namespace JsBinary {
         IdentityEquals = 1,
         IdentityNotEquals = 2,
         In = 3,
-        QuestionQuestion = 4
+        QuestionQuestion = 4,
+        Comma = 5
     }
 }
+declare const LiteralType_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 LiteralType extends LiteralType_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, literal: Expression, _type: JavaType);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): LiteralType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): LiteralType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): LiteralType;
+    private readonly _literal;
+    get literal(): Expression;
+    withLiteral(literal: Expression): LiteralType;
+    private readonly _type;
+    get type(): JavaType;
+    withType(_type: JavaType): LiteralType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+}
 declare const ObjectBindingDeclarations_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -824,6 +975,55 @@ export declare class PropertyAssignment extends PropertyAssignment_base implemen
         withName(name: JRightPadded<Expression>): PropertyAssignment;
     };
 }
+declare const SatisfiesExpression_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 SatisfiesExpression extends SatisfiesExpression_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, expression: J, satisfiesType: JLeftPadded<Expression>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): SatisfiesExpression;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): SatisfiesExpression;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): SatisfiesExpression;
+    private readonly _expression;
+    get expression(): J;
+    withExpression(expression: J): SatisfiesExpression;
+    private readonly _satisfiesType;
+    get satisfiesType(): Expression;
+    withSatisfiesType(satisfiesType: Expression): SatisfiesExpression;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): SatisfiesExpression;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly satisfiesType: JLeftPadded<Expression>;
+        withSatisfiesType(satisfiesType: JLeftPadded<Expression>): SatisfiesExpression;
+    };
+}
 declare const ScopedVariableDeclarations_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -1240,7 +1440,7 @@ declare const TypeOperator_base: ((abstract new (...args: any[]) => {
     isJava: boolean;
     isJavaScript: boolean;
 }) & ObjectConstructor;
-export declare class TypeOperator extends TypeOperator_base implements Expression, TypedTree, NameTree {
+export declare class TypeOperator extends TypeOperator_base implements Expression, TypeTree {
     constructor(id: UUID, prefix: Space, markers: Markers, operator: TypeOperator.Type, expression: JLeftPadded<Expression>);
     private readonly _id;
     get id(): UUID;
@@ -1271,6 +1471,60 @@ export declare namespace TypeOperator {
         KeyOf = 1
     }
 }
+declare const TypePredicate_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 TypePredicate extends TypePredicate_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, asserts: JLeftPadded<boolean>, parameterName: Java.Identifier, expression: JLeftPadded<Expression> | null, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): TypePredicate;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): TypePredicate;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): TypePredicate;
+    private readonly _asserts;
+    get asserts(): boolean;
+    withAsserts(asserts: boolean): TypePredicate;
+    private readonly _parameterName;
+    get parameterName(): Java.Identifier;
+    withParameterName(parameterName: Java.Identifier): TypePredicate;
+    private readonly _expression;
+    get expression(): Expression | null;
+    withExpression(expression: Expression | null): TypePredicate;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): TypePredicate;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly asserts: JLeftPadded<boolean>;
+        withAsserts(asserts: JLeftPadded<boolean>): TypePredicate;
+        readonly expression: JLeftPadded<Expression> | null;
+        withExpression(expression: JLeftPadded<Expression> | null): TypePredicate;
+    };
+}
 declare const Unary_base: ((abstract new (...args: any[]) => {
     readonly prefix: Space;
     withPrefix(prefix: Space): JS;
@@ -1861,7 +2115,7 @@ declare const JSForInOfLoopControl_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class JSForInOfLoopControl extends JSForInOfLoopControl_base {
-    constructor(id: UUID, prefix: Space, markers: Markers, variable: JRightPadded<Statement>, iterable: JRightPadded<Expression>);
+    constructor(id: UUID, prefix: Space, markers: Markers, variable: JRightPadded<J>, iterable: JRightPadded<Expression>);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): JSForInOfLoopControl;
@@ -1872,15 +2126,15 @@ export declare class JSForInOfLoopControl extends JSForInOfLoopControl_base {
     get markers(): Markers;
     withMarkers(markers: Markers): JSForInOfLoopControl;
     private readonly _variable;
-    get variable(): Statement;
-    withVariable(variable: Statement): JSForInOfLoopControl;
+    get variable(): J;
+    withVariable(variable: J): JSForInOfLoopControl;
     private readonly _iterable;
     get iterable(): Expression;
     withIterable(iterable: Expression): JSForInOfLoopControl;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get padding(): {
-        readonly variable: JRightPadded<Statement>;
-        withVariable(variable: JRightPadded<Statement>): JSForInOfLoopControl;
+        readonly variable: JRightPadded<J>;
+        withVariable(variable: JRightPadded<J>): JSForInOfLoopControl;
         readonly iterable: JRightPadded<Expression>;
         withIterable(iterable: JRightPadded<Expression>): JSForInOfLoopControl;
     };
@@ -1969,7 +2223,7 @@ declare const FunctionDeclaration_base: ((abstract new (...args: any[]) => {
     isJavaScript: boolean;
 }) & ObjectConstructor;
 export declare class FunctionDeclaration extends FunctionDeclaration_base implements Statement, Expression, TypedTree {
-    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], name: Java.Identifier | null, typeParameters: Java.TypeParameters | null, parameters: JContainer<Statement>, returnTypeExpression: TypeTree | null, body: J, _type: JavaType | null);
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], asteriskToken: JLeftPadded<boolean>, name: JLeftPadded<Java.Identifier>, typeParameters: Java.TypeParameters | null, parameters: JContainer<Statement>, returnTypeExpression: TypeTree | null, body: J, _type: JavaType | null);
     private readonly _id;
     get id(): UUID;
     withId(id: UUID): FunctionDeclaration;
@@ -1982,9 +2236,12 @@ export declare class FunctionDeclaration extends FunctionDeclaration_base implem
     private readonly _modifiers;
     get modifiers(): Java.Modifier[];
     withModifiers(modifiers: Java.Modifier[]): FunctionDeclaration;
+    private readonly _asteriskToken;
+    get asteriskToken(): boolean;
+    withAsteriskToken(asteriskToken: boolean): FunctionDeclaration;
     private readonly _name;
-    get name(): Java.Identifier | null;
-    withName(name: Java.Identifier | null): FunctionDeclaration;
+    get name(): Java.Identifier;
+    withName(name: Java.Identifier): FunctionDeclaration;
     private readonly _typeParameters;
     get typeParameters(): Java.TypeParameters | null;
     withTypeParameters(typeParameters: Java.TypeParameters | null): FunctionDeclaration;
@@ -2002,6 +2259,10 @@ export declare class FunctionDeclaration extends FunctionDeclaration_base implem
     withType(_type: JavaType | null): FunctionDeclaration;
     acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
     get padding(): {
+        readonly asteriskToken: JLeftPadded<boolean>;
+        withAsteriskToken(asteriskToken: JLeftPadded<boolean>): FunctionDeclaration;
+        readonly name: JLeftPadded<Java.Identifier>;
+        withName(name: JLeftPadded<Java.Identifier>): FunctionDeclaration;
         readonly parameters: JContainer<Statement>;
         withParameters(parameters: JContainer<Statement>): FunctionDeclaration;
     };
@@ -2204,5 +2465,360 @@ export declare class BindingElement extends BindingElement_base implements State
         withInitializer(initializer: JLeftPadded<Expression> | null): BindingElement;
     };
 }
+declare const ExportDeclaration_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 ExportDeclaration extends ExportDeclaration_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], typeOnly: JLeftPadded<boolean>, exportClause: Expression | null, moduleSpecifier: JLeftPadded<Expression> | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ExportDeclaration;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ExportDeclaration;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ExportDeclaration;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): ExportDeclaration;
+    private readonly _typeOnly;
+    get typeOnly(): boolean;
+    withTypeOnly(typeOnly: boolean): ExportDeclaration;
+    private readonly _exportClause;
+    get exportClause(): Expression | null;
+    withExportClause(exportClause: Expression | null): ExportDeclaration;
+    private readonly _moduleSpecifier;
+    get moduleSpecifier(): Expression | null;
+    withModuleSpecifier(moduleSpecifier: Expression | null): ExportDeclaration;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly typeOnly: JLeftPadded<boolean>;
+        withTypeOnly(typeOnly: JLeftPadded<boolean>): ExportDeclaration;
+        readonly moduleSpecifier: JLeftPadded<Expression> | null;
+        withModuleSpecifier(moduleSpecifier: JLeftPadded<Expression> | null): ExportDeclaration;
+    };
+}
+declare const ExportAssignment_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 ExportAssignment extends ExportAssignment_base implements Statement {
+    constructor(id: UUID, prefix: Space, markers: Markers, modifiers: Java.Modifier[], exportEquals: JLeftPadded<boolean>, expression: Expression | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ExportAssignment;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ExportAssignment;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ExportAssignment;
+    private readonly _modifiers;
+    get modifiers(): Java.Modifier[];
+    withModifiers(modifiers: Java.Modifier[]): ExportAssignment;
+    private readonly _exportEquals;
+    get exportEquals(): boolean;
+    withExportEquals(exportEquals: boolean): ExportAssignment;
+    private readonly _expression;
+    get expression(): Expression | null;
+    withExpression(expression: Expression | null): ExportAssignment;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly exportEquals: JLeftPadded<boolean>;
+        withExportEquals(exportEquals: JLeftPadded<boolean>): ExportAssignment;
+    };
+}
+declare const NamedExports_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 NamedExports extends NamedExports_base implements Expression {
+    constructor(id: UUID, prefix: Space, markers: Markers, elements: JContainer<ExportSpecifier>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): NamedExports;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): NamedExports;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): NamedExports;
+    private readonly _elements;
+    get elements(): ExportSpecifier[];
+    withElements(elements: ExportSpecifier[]): NamedExports;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): NamedExports;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly elements: JContainer<ExportSpecifier>;
+        withElements(elements: JContainer<ExportSpecifier>): NamedExports;
+    };
+}
+declare const ExportSpecifier_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 ExportSpecifier extends ExportSpecifier_base implements Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, typeOnly: JLeftPadded<boolean>, specifier: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): ExportSpecifier;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): ExportSpecifier;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): ExportSpecifier;
+    private readonly _typeOnly;
+    get typeOnly(): boolean;
+    withTypeOnly(typeOnly: boolean): ExportSpecifier;
+    private readonly _specifier;
+    get specifier(): Expression;
+    withSpecifier(specifier: Expression): ExportSpecifier;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): ExportSpecifier;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly typeOnly: JLeftPadded<boolean>;
+        withTypeOnly(typeOnly: JLeftPadded<boolean>): ExportSpecifier;
+    };
+}
+declare const IndexedAccessType_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 IndexedAccessType extends IndexedAccessType_base implements Expression, TypeTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, objectType: TypeTree, indexType: JRightPadded<TypeTree>, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): IndexedAccessType;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): IndexedAccessType;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): IndexedAccessType;
+    private readonly _objectType;
+    get objectType(): TypeTree;
+    withObjectType(objectType: TypeTree): IndexedAccessType;
+    private readonly _indexType;
+    get indexType(): TypeTree;
+    withIndexType(indexType: TypeTree): IndexedAccessType;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): IndexedAccessType;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly indexType: JRightPadded<TypeTree>;
+        withIndexType(indexType: JRightPadded<TypeTree>): IndexedAccessType;
+    };
+}
+export declare namespace IndexedAccessType {
+    const IndexType_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 IndexType extends IndexType_base implements Expression, TypeTree {
+        constructor(id: UUID, prefix: Space, markers: Markers, element: JRightPadded<TypeTree>, _type: JavaType | null);
+        private readonly _id;
+        get id(): UUID;
+        withId(id: UUID): IndexedAccessType.IndexType;
+        private readonly _prefix;
+        get prefix(): Space;
+        withPrefix(prefix: Space): IndexedAccessType.IndexType;
+        private readonly _markers;
+        get markers(): Markers;
+        withMarkers(markers: Markers): IndexedAccessType.IndexType;
+        private readonly _element;
+        get element(): TypeTree;
+        withElement(element: TypeTree): IndexedAccessType.IndexType;
+        private readonly _type;
+        get type(): JavaType | null;
+        withType(_type: JavaType | null): IndexedAccessType.IndexType;
+        acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+        get padding(): {
+            readonly element: JRightPadded<TypeTree>;
+            withElement(element: JRightPadded<TypeTree>): IndexedAccessType.IndexType;
+        };
+    }
+    export {};
+}
+declare const JsAssignmentOperation_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 JsAssignmentOperation extends JsAssignmentOperation_base implements Statement, Expression, TypedTree {
+    constructor(id: UUID, prefix: Space, markers: Markers, variable: Expression, operator: JLeftPadded<JsAssignmentOperation.Type>, assignment: Expression, _type: JavaType | null);
+    private readonly _id;
+    get id(): UUID;
+    withId(id: UUID): JsAssignmentOperation;
+    private readonly _prefix;
+    get prefix(): Space;
+    withPrefix(prefix: Space): JsAssignmentOperation;
+    private readonly _markers;
+    get markers(): Markers;
+    withMarkers(markers: Markers): JsAssignmentOperation;
+    private readonly _variable;
+    get variable(): Expression;
+    withVariable(variable: Expression): JsAssignmentOperation;
+    private readonly _operator;
+    get operator(): JsAssignmentOperation.Type;
+    withOperator(operator: JsAssignmentOperation.Type): JsAssignmentOperation;
+    private readonly _assignment;
+    get assignment(): Expression;
+    withAssignment(assignment: Expression): JsAssignmentOperation;
+    private readonly _type;
+    get type(): JavaType | null;
+    withType(_type: JavaType | null): JsAssignmentOperation;
+    acceptJavaScript<P>(v: JavaScriptVisitor<P>, p: P): J | null;
+    get padding(): {
+        readonly operator: JLeftPadded<JsAssignmentOperation.Type>;
+        withOperator(operator: JLeftPadded<JsAssignmentOperation.Type>): JsAssignmentOperation;
+    };
+}
+export declare namespace JsAssignmentOperation {
+    enum Type {
+        QuestionQuestion = 0,
+        And = 1,
+        Or = 2
+    }
+}
 export {};
 //# sourceMappingURL=tree.d.ts.map