@artel/artc 0.6.25191

package/build/types/emitter/ir/Nodes.d.ts

@@ -0,0 +1,1585 @@
+import * as indexerAccess from '../../analysis/IndexerAccess.js';
+import * as variableAccess from '../../analysis/VariableAccess.js';
+import { Name } from '../../common/Name.js';
+import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, GetterEntity, IndexerEntity, MethodEntity, PackageEntity, PackageVariableEntity, SetterEntity, TypeEntity, TypeEntityWithMembers, TypeExtensionEntity, TypeMethodEntity, TypeVariableEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../../entities/index.js';
+import * as types from '../../types/index.js';
+import { AccessedIndexer, AccessedMethod, AccessedVariable } from './AccessedEntities.js';
+import { AssignmentLoweringOptions, CallExpressionLoweringOptions, ConstructorCallExpressionLoweringOptions, DeclarationWithInitializerLoweringOptions, MethodAccessLoweringOptions, TextTemplateLiteralLoweringOptions } from './LoweringOptions.js';
+import { SourceLocation } from './SourceLocation.js';
+import { BlockStatementClause, Expression, LValueExpression, PackageMemberDeclaration, Statement, TypeMemberDeclaration } from './types.js';
+export declare class ArrayLiteral {
+    private _elements;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.ArrayLiteral;
+    get elements(): readonly Expression[];
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_elements: readonly Expression[], _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(elements: readonly Expression[], type: types.Type): void;
+    clone(): ArrayLiteral;
+}
+export declare class AsExpression {
+    private _expression;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.AsExpression;
+    get expression(): Expression;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, type: types.Type): void;
+    clone(): AsExpression;
+}
+export declare class AssertionExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.AssertionExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): AssertionExpression;
+}
+export declare class AssignmentExpression {
+    private _left;
+    private _operator;
+    private _right;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.AssignmentExpression;
+    get left(): LValueExpression;
+    get operator(): AssignmentOperator;
+    get right(): Expression;
+    get loweringOptions(): AssignmentLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_left: LValueExpression, _operator: AssignmentOperator, _right: Expression, _sourceLocation: SourceLocation | undefined, _loweringOptions?: AssignmentLoweringOptions);
+    update(left: LValueExpression, operator: AssignmentOperator, right: Expression, loweringOptions: AssignmentLoweringOptions): void;
+    clone(): AssignmentExpression;
+}
+export declare class AssignmentStatement {
+    private _left;
+    private _operator;
+    private _right;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.AssignmentStatement;
+    get left(): LValueExpression;
+    get operator(): AssignmentOperator;
+    get right(): Expression;
+    get loweringOptions(): AssignmentLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_left: LValueExpression, _operator: AssignmentOperator, _right: Expression, _sourceLocation: SourceLocation | undefined, _loweringOptions?: AssignmentLoweringOptions);
+    update(left: LValueExpression, operator: AssignmentOperator, right: Expression, loweringOptions: AssignmentLoweringOptions): void;
+    clone(): AssignmentStatement;
+}
+export declare const enum AssignmentOperator {
+    Equals = 0,
+    AddEquals = 1,
+    SubtractEquals = 2,
+    MultiplyEquals = 3,
+    DivideEquals = 4,
+    IntegerDivideEquals = 5
+}
+export declare class AssumptionExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.AssumptionExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): AssumptionExpression;
+}
+export declare class BaseConstructorCallExpression {
+    private _entity;
+    private _containingTypeOfConstructor;
+    private _callArguments;
+    private _sourceLocation;
+    readonly kind = NodeKind.BaseConstructorCallExpression;
+    get entity(): ConstructorEntity;
+    get containingTypeOfConstructor(): TypeEntityWithMembers;
+    get callArguments(): CallArguments;
+    get isOverloadedConstructorCall(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: ConstructorEntity, _containingTypeOfConstructor: TypeEntityWithMembers, _callArguments: CallArguments, _sourceLocation: SourceLocation | undefined);
+    update(entity: ConstructorEntity, callArguments: CallArguments): void;
+    clone(): BaseConstructorCallExpression;
+}
+export declare class BaseExpression {
+    private _sourceLocation;
+    readonly kind = NodeKind.BaseExpression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_sourceLocation: SourceLocation | undefined);
+    clone(): BaseExpression;
+}
+export declare class BinaryExpression {
+    private _left;
+    private _operator;
+    private _right;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.BinaryExpression;
+    get left(): Expression;
+    get operator(): BinaryExpressionOperator;
+    get right(): Expression;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_left: Expression, _operator: BinaryExpressionOperator, _right: Expression, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(left: Expression, operator: BinaryExpressionOperator, right: Expression, type: types.Type): void;
+    clone(): BinaryExpression;
+}
+export declare class BlockStatement {
+    private _statements;
+    private _clauses;
+    private _sourceLocation;
+    readonly kind = NodeKind.BlockStatement;
+    get statements(): readonly Statement[];
+    get clauses(): readonly BlockStatementClause[];
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_statements: readonly Statement[], _clauses: readonly BlockStatementClause[], _sourceLocation: SourceLocation | undefined);
+    update(statements: readonly Statement[], clauses: readonly BlockStatementClause[]): void;
+    clone(): BlockStatement;
+}
+export declare class BooleanLiteral {
+    private _value;
+    private _sourceLocation;
+    readonly kind = NodeKind.BooleanLiteral;
+    get value(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_value: boolean, _sourceLocation: SourceLocation | undefined);
+    update(value: boolean): void;
+    clone(): BooleanLiteral;
+}
+export declare class BreakLoopStatement {
+    private _label;
+    private _sourceLocation;
+    readonly kind = NodeKind.BreakLoopStatement;
+    get label(): string;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_label: string, _sourceLocation: SourceLocation | undefined);
+    clone(): BreakLoopStatement;
+}
+export declare class CallArgument {
+    private _expression;
+    readonly targetParameter: TargetParameter;
+    readonly kind = NodeKind.CallArgument;
+    get expression(): Expression;
+    constructor(_expression: Expression, targetParameter: TargetParameter);
+    update(expression: Expression): void;
+    clone(): CallArgument;
+}
+export declare class TargetParameter {
+    readonly entity: VariableEntity;
+    readonly type: types.Type;
+    constructor(entity: VariableEntity, type: types.Type);
+}
+export type CallArguments = UnorderedCallArguments | OrderedCallArguments;
+export declare class UnorderedCallArguments {
+    readonly values: readonly CallArgument[];
+    readonly targetParameters: readonly VariableEntity[];
+    readonly kind = "unordered";
+    constructor(values: readonly CallArgument[], targetParameters: readonly VariableEntity[]);
+    clone(): UnorderedCallArguments;
+}
+export declare class OrderedCallArguments {
+    private _values;
+    private _isLastArgumentSpreading;
+    readonly kind = "ordered";
+    get values(): readonly Expression[];
+    get isLastArgumentSpreading(): boolean;
+    constructor(_values: readonly Expression[], _isLastArgumentSpreading: boolean);
+    update(values: readonly Expression[], isLastArgumentSpreading: boolean): void;
+    clone(): OrderedCallArguments;
+}
+export declare class CallExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _callArguments;
+    private _isAsyncMethodCall;
+    private _returnType;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.CallExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get callArguments(): CallArguments;
+    get isAsyncMethodCall(): boolean;
+    get returnType(): types.Type;
+    get loweringOptions(): CallExpressionLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _callArguments: CallArguments, _isAsyncMethodCall: boolean, _returnType: types.Type, _sourceLocation: SourceLocation | undefined, _loweringOptions?: CallExpressionLoweringOptions);
+    update(expression: Expression, isOptionalChaining: boolean, callArguments: CallArguments, isAsyncMethodCall: boolean, returnType: types.Type, loweringOptions: CallExpressionLoweringOptions): void;
+    clone(): CallExpression;
+}
+export declare class CharLiteral {
+    private _value;
+    private _sourceLocation;
+    readonly kind = NodeKind.CharLiteral;
+    get value(): string;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_value: string, _sourceLocation: SourceLocation | undefined);
+    update(value: string): void;
+    clone(): CharLiteral;
+}
+export declare class CommaExpression {
+    private _expressions;
+    private _sourceLocation;
+    readonly kind = NodeKind.CommaExpression;
+    get expressions(): readonly Expression[];
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expressions: readonly Expression[], _sourceLocation: SourceLocation | undefined);
+    update(expressions: readonly Expression[]): void;
+    clone(): CommaExpression;
+}
+export declare class ConstructorCallExpression {
+    private _entity;
+    private _containingTypeOfConstructor;
+    private _typeAccess;
+    private _callArguments;
+    private _isOverloadedConstructorCall;
+    private _returnType;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.ConstructorCallExpression;
+    get entity(): ConstructorEntity;
+    get containingTypeOfConstructor(): TypeEntityWithMembers;
+    get typeAccess(): TypeAccessExpression;
+    get callArguments(): CallArguments;
+    get isOverloadedConstructorCall(): boolean;
+    get returnType(): types.Type;
+    get loweringOptions(): ConstructorCallExpressionLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: ConstructorEntity, _containingTypeOfConstructor: TypeEntityWithMembers, _typeAccess: TypeAccessExpression, _callArguments: CallArguments, _isOverloadedConstructorCall: boolean, _returnType: types.Type, _sourceLocation: SourceLocation | undefined, _loweringOptions?: ConstructorCallExpressionLoweringOptions);
+    update(entity: ConstructorEntity, containingTypeOfConstructor: TypeEntityWithMembers, typeAccess: TypeAccessExpression, callArguments: CallArguments, isOverloadedConstructorCall: boolean): void;
+    clone(): ConstructorCallExpression;
+}
+export declare class ContinueLoopStatement {
+    private _label;
+    private _sourceLocation;
+    readonly kind = NodeKind.ContinueLoopStatement;
+    get label(): string;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_label: string, _sourceLocation: SourceLocation | undefined);
+    clone(): ContinueLoopStatement;
+}
+export declare class DereferenceExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _entity;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.DereferenceExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get entity(): DereferenceOperatorEntity;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _entity: DereferenceOperatorEntity, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): DereferenceExpression;
+}
+export declare class DisposeStatement {
+    private _expression;
+    private _destructorEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.DisposeStatement;
+    get expression(): Expression;
+    get destructorEntity(): DestructorEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _destructorEntity: DestructorEntity, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, destructorEntity: DestructorEntity): void;
+    clone(): DisposeStatement;
+}
+export declare class EmptyStatement {
+    private _sourceLocation;
+    readonly kind = NodeKind.EmptyStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_sourceLocation: SourceLocation | undefined);
+    clone(): EmptyStatement;
+}
+export declare class ErrorStatement {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.ErrorStatement;
+    get expression(): Expression | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression | undefined, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression | undefined): void;
+    clone(): ErrorStatement;
+}
+export declare class ExpressionStatement {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.ExpressionStatement;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): ExpressionStatement;
+}
+export declare class FinallyClause {
+    private _body;
+    private _sourceLocation;
+    readonly kind = NodeKind.FinallyClause;
+    get body(): BlockStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): FinallyClause;
+}
+export declare class ForStatement {
+    private _label;
+    private _enumerationVariableEntity;
+    private _indexVariableEntity;
+    private _enumeratedExpression;
+    private _body;
+    private _sourceLocation;
+    readonly kind = NodeKind.ForStatement;
+    get label(): string | undefined;
+    get enumerationVariableEntity(): VariableEntity;
+    get indexVariableEntity(): VariableEntity | undefined;
+    get enumeratedExpression(): Expression;
+    get body(): BlockStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_label: string | undefined, _enumerationVariableEntity: VariableEntity, _indexVariableEntity: VariableEntity | undefined, _enumeratedExpression: Expression, _body: BlockStatement, _sourceLocation: SourceLocation | undefined);
+    update(enumerationVariableEntity: VariableEntity, indexVariableEntity: VariableEntity | undefined, enumeratedExpression: Expression, body: BlockStatement): void;
+    clone(): ForStatement;
+}
+export declare class HelperMethodCallExpression {
+    private _methodName;
+    private _callArguments;
+    private _isAsyncMethodCall;
+    private _returnType;
+    private _sourceLocation;
+    readonly kind = NodeKind.HelperMethodCallExpression;
+    get methodName(): string;
+    get callArguments(): readonly Expression[];
+    get isAsyncMethodCall(): boolean;
+    get returnType(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_methodName: string, _callArguments: readonly Expression[], _isAsyncMethodCall: boolean, _returnType: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(callArguments: readonly Expression[]): void;
+    clone(): HelperMethodCallExpression;
+}
+export declare class IfStatement {
+    private _condition;
+    private _thenStatement;
+    private _elseStatement;
+    private _sourceLocation;
+    readonly kind = NodeKind.IfStatement;
+    get condition(): Expression;
+    get thenStatement(): BlockStatement;
+    get elseStatement(): BlockStatement | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_condition: Expression, _thenStatement: BlockStatement, _elseStatement: BlockStatement | undefined, _sourceLocation: SourceLocation | undefined);
+    update(condition: Expression, thenStatement: BlockStatement, elseStatement: BlockStatement | undefined): void;
+    clone(): IfStatement;
+}
+export declare class ImplicitConversionExpression {
+    private _expression;
+    private _conversionKind;
+    private _sourceLocation;
+    readonly kind = NodeKind.ImplicitConversionExpression;
+    get expression(): Expression;
+    get conversionKind(): ImplicitConversionKind;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _conversionKind: ImplicitConversionKind, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, conversionKind: ImplicitConversionKind): void;
+    clone(): ImplicitConversionExpression;
+}
+export declare const enum ImplicitConversionKind {
+    TextTemplateToText = 0
+}
+export declare class ImplicitVariantAccessExpression {
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.ImplicitVariantAccessExpression;
+    get entity(): VariantEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: VariantEntity, _sourceLocation: SourceLocation | undefined);
+    update(entity: VariantEntity): void;
+    clone(): ImplicitVariantAccessExpression;
+}
+export declare class IndexedAccessExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _arguments;
+    private _indexer;
+    private _access;
+    private _sourceLocation;
+    readonly kind = NodeKind.IndexedAccessExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get arguments(): readonly Expression[];
+    get indexer(): AccessedIndexer;
+    get access(): indexerAccess.IndexerAccess;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _arguments: readonly Expression[], _indexer: AccessedIndexer, _access: indexerAccess.IndexerAccess, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, isOptionalChaining: boolean, args: readonly Expression[], indexer: AccessedIndexer, access: indexerAccess.IndexerAccess): void;
+    clone(): IndexedAccessExpression;
+}
+export declare class InlineJsExpression {
+    private _code;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.InlineJsExpression;
+    get code(): string;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_code: string, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(code: string): void;
+    clone(): InlineJsExpression;
+}
+export declare class IntegerLiteral {
+    private _value;
+    private _sourceLocation;
+    readonly kind = NodeKind.IntegerLiteral;
+    get value(): number;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_value: number, _sourceLocation: SourceLocation | undefined);
+    update(value: number): void;
+    clone(): IntegerLiteral;
+}
+export declare class IsExpression {
+    private _expression;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.IsExpression;
+    get expression(): Expression;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, type: types.Type): void;
+    clone(): IsExpression;
+}
+export declare class JsFunctionLiteral {
+    private _valueParameters;
+    private _body;
+    private _isAsync;
+    private _isGenerator;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsFunctionLiteral;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get isAsync(): boolean;
+    get isGenerator(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _isAsync: boolean, _isGenerator: boolean, _sourceLocation: SourceLocation | undefined);
+    update(valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement, isAsync: boolean): void;
+    clone(): JsFunctionLiteral;
+}
+export declare class JsIdentifierExpression {
+    private _identifier;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsIdentifierExpression;
+    get identifier(): string;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_identifier: string, _sourceLocation: SourceLocation | undefined);
+    update(identifier: string): void;
+    clone(): JsIdentifierExpression;
+}
+export type JsModuleImportDirectiveStatement = EsModuleImportDirectiveStatement | CjsModuleImportDirectiveStatement;
+export declare class EsModuleImportDirectiveStatement {
+    readonly defaultImport: string | undefined;
+    readonly importSpecifiers: readonly JsImportSpecifier[];
+    readonly path: string;
+    readonly kind = NodeKind.EsModuleImportDirectiveStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(defaultImport: string | undefined, importSpecifiers: readonly JsImportSpecifier[], path: string);
+    clone(): EsModuleImportDirectiveStatement;
+}
+export declare class CjsModuleImportDirectiveStatement {
+    readonly defaultImport: string;
+    readonly importSpecifiers: readonly JsImportSpecifier[];
+    readonly path: string;
+    readonly kind = NodeKind.CjsModuleImportDirectiveStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(defaultImport: string, importSpecifiers: readonly JsImportSpecifier[], path: string);
+    clone(): CjsModuleImportDirectiveStatement;
+}
+export declare class JsImportSpecifier {
+    readonly name: string;
+    readonly alias: string | undefined;
+    readonly kind = NodeKind.JsImportSpecifier;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(name: string, alias: string | undefined);
+    clone(): JsImportSpecifier;
+}
+export declare class JsIndexedAccessExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _argument;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsIndexedAccessExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get argument(): Expression;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _argument: Expression, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, isOptionalChaining: boolean, argument: Expression): void;
+    clone(): JsIndexedAccessExpression;
+}
+export declare class JsInstanceOfExpression {
+    private _expression;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsInstanceOfExpression;
+    get expression(): Expression;
+    get type(): TypeEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _type: TypeEntity, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, type: TypeEntity): void;
+    clone(): JsInstanceOfExpression;
+}
+export declare class JsNamespaceDestructuringStatement {
+    readonly defaultImport: string | undefined;
+    readonly destructuredMembers: readonly JsImportSpecifier[];
+    readonly namespaceNameSegments: readonly string[];
+    readonly kind = NodeKind.JsNamespaceDestructuringStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(defaultImport: string | undefined, destructuredMembers: readonly JsImportSpecifier[], namespaceNameSegments: readonly string[]);
+    clone(): JsNamespaceDestructuringStatement;
+}
+export declare class JsObjectLiteral {
+    private _properties;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsObjectLiteral;
+    get properties(): readonly JsObjectLiteralProperty[];
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_properties: readonly JsObjectLiteralProperty[], _sourceLocation: SourceLocation | undefined);
+    update(properties: readonly JsObjectLiteralProperty[]): void;
+    clone(): JsObjectLiteral;
+}
+export declare class JsObjectLiteralProperty {
+    private _name;
+    private _value;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsObjectLiteralProperty;
+    get name(): string;
+    get value(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_name: string, _value: Expression, _sourceLocation: SourceLocation | undefined);
+    update(name: string, value: Expression): void;
+    clone(): JsObjectLiteralProperty;
+}
+export declare class JsPropertyAccessExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _name;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsPropertyAccessExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get name(): string;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _name: string, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression, isOptionalChaining: boolean, name: string, type: types.Type): void;
+    clone(): JsPropertyAccessExpression;
+}
+export declare class JsTypeOfExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.JsTypeOfExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): JsTypeOfExpression;
+}
+export declare class LocalVariableDeclaration {
+    private _entity;
+    private _initializer;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.LocalVariableDeclaration;
+    get entity(): VariableEntity;
+    get initializer(): Expression | undefined;
+    get loweringOptions(): DeclarationWithInitializerLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: VariableEntity, _initializer: Expression | undefined, _sourceLocation: SourceLocation | undefined, _loweringOptions?: DeclarationWithInitializerLoweringOptions);
+    update(initializer: Expression | undefined, loweringOptions: DeclarationWithInitializerLoweringOptions): void;
+    clone(): LocalVariableDeclaration;
+}
+export declare class LocalVariableDeclarationStatement {
+    private _declaration;
+    private _sourceLocation;
+    readonly kind = NodeKind.LocalVariableDeclarationStatement;
+    get declaration(): LocalVariableDeclaration;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_declaration: LocalVariableDeclaration, _sourceLocation: SourceLocation | undefined);
+    update(declaration: LocalVariableDeclaration): void;
+    clone(): LocalVariableDeclarationStatement;
+}
+export declare class LoopStatement {
+    private _label;
+    private _body;
+    private _condition;
+    private _sourceLocation;
+    readonly kind = NodeKind.LoopStatement;
+    get label(): string | undefined;
+    get body(): BlockStatement;
+    get condition(): Expression | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_label: string | undefined, _body: BlockStatement, _condition: Expression | undefined, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement, condition: Expression | undefined): void;
+    clone(): LoopStatement;
+}
+export declare class MeasureLiteral {
+    private _sourceLocation;
+    readonly kind = NodeKind.MeasureLiteral;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_sourceLocation: SourceLocation | undefined);
+    clone(): MeasureLiteral;
+}
+export declare class MethodAccessExpression {
+    private _method;
+    private _isCallee;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.MethodAccessExpression;
+    get method(): AccessedMethod;
+    get isCallee(): boolean;
+    get loweringOptions(): MethodAccessLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_method: AccessedMethod, _isCallee: boolean, _sourceLocation: SourceLocation | undefined, _loweringOptions?: MethodAccessLoweringOptions);
+    update(method: AccessedMethod, loweringOptions: MethodAccessLoweringOptions): void;
+    clone(): MethodAccessExpression;
+}
+export declare class MethodLiteral {
+    private _valueParameters;
+    private _body;
+    private _isAsync;
+    private _returnType;
+    private _resultLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.MethodLiteral;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get isAsync(): boolean;
+    get returnType(): types.Type;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _isAsync: boolean, _returnType: types.Type, _resultLocalVariableEntity: VariableEntity | undefined, _sourceLocation: SourceLocation | undefined);
+    update(valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement, isAsync: boolean): void;
+    clone(): MethodLiteral;
+}
+export declare class Modifiers {
+    private _flags;
+    constructor(_flags?: ModifierFlag);
+    makeExport(): void;
+    makeStatic(): void;
+    makeAsync(): void;
+    removeExport(): void;
+    removeStatic(): void;
+    removeAsync(): void;
+    isExport(): boolean;
+    isStatic(): boolean;
+    isAsync(): boolean;
+}
+export declare const enum ModifierFlag {
+    None = 0,
+    Export = 1,
+    Static = 2,
+    Async = 4
+}
+export declare class NestedMethodDeclaration {
+    private _valueParameters;
+    private _body;
+    private _entity;
+    private _isAsync;
+    private _resultLocalVariableEntity;
+    private _isGenerator;
+    private _sourceLocation;
+    readonly kind = NodeKind.NestedMethodDeclaration;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get entity(): MethodEntity;
+    get isAsync(): boolean;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get isGenerator(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _entity: MethodEntity, _isAsync: boolean, _resultLocalVariableEntity: VariableEntity | undefined, _isGenerator: boolean, _sourceLocation: SourceLocation | undefined);
+    update(valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement, isAsync: boolean): void;
+    clone(): NestedMethodDeclaration;
+}
+export declare class NestedMethodDeclarationStatement {
+    private _declaration;
+    private _sourceLocation;
+    readonly kind = NodeKind.NestedMethodDeclarationStatement;
+    get declaration(): NestedMethodDeclaration;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_declaration: NestedMethodDeclaration, _sourceLocation: SourceLocation | undefined);
+    update(declaration: NestedMethodDeclaration): void;
+    clone(): NestedMethodDeclarationStatement;
+}
+export declare class NoneLiteral {
+    private _sourceLocation;
+    readonly kind = NodeKind.NoneLiteral;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_sourceLocation: SourceLocation | undefined);
+    clone(): NoneLiteral;
+}
+export declare class NotExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.NotExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): NotExpression;
+}
+export declare class NumericLiteral {
+    private _value;
+    private _sourceLocation;
+    readonly kind = NodeKind.NumericLiteral;
+    get value(): number;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_value: number, _sourceLocation: SourceLocation | undefined);
+    update(value: number): void;
+    clone(): NumericLiteral;
+}
+export declare class OnErrorClause {
+    private _errorVariableEntity;
+    private _body;
+    private _sourceLocation;
+    readonly kind = NodeKind.OnErrorClause;
+    get errorVariableEntity(): VariableEntity | undefined;
+    get body(): BlockStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_errorVariableEntity: VariableEntity | undefined, _body: BlockStatement, _sourceLocation: SourceLocation | undefined);
+    update(errorVariableEntity: VariableEntity | undefined, body: BlockStatement): void;
+    clone(): OnErrorClause;
+}
+export declare class OwnConstructorCallExpression {
+    private _entity;
+    private _containingTypeOfConstructor;
+    private _callArguments;
+    private _sourceLocation;
+    readonly kind = NodeKind.OwnConstructorCallExpression;
+    get entity(): ConstructorEntity;
+    get containingTypeOfConstructor(): TypeEntityWithMembers;
+    get callArguments(): CallArguments;
+    get isOverloadedConstructorCall(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: ConstructorEntity, _containingTypeOfConstructor: TypeEntityWithMembers, _callArguments: CallArguments, _sourceLocation: SourceLocation | undefined);
+    update(entity: ConstructorEntity, callArguments: CallArguments): void;
+    clone(): OwnConstructorCallExpression;
+}
+export declare class PackageConstructorDeclaration {
+    private _body;
+    private _isAsync;
+    private _containingPackage;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageConstructorDeclaration;
+    get body(): BlockStatement;
+    get isAsync(): boolean;
+    get containingPackage(): PackageEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _isAsync: boolean, _containingPackage: PackageEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): PackageConstructorDeclaration;
+}
+export declare class PackageEntryPointDeclaration {
+    private _body;
+    private _isAsync;
+    private _containingPackage;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageEntryPointDeclaration;
+    get body(): BlockStatement;
+    get isAsync(): boolean;
+    get containingPackage(): PackageEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _isAsync: boolean, _containingPackage: PackageEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): PackageEntryPointDeclaration;
+}
+export declare class PackageMethodDeclaration {
+    private _modifiers;
+    private _valueParameters;
+    private _body;
+    private _entity;
+    private _resultLocalVariableEntity;
+    private _paramLocalVariableEntity;
+    private _isGenerator;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageMethodDeclaration;
+    get modifiers(): Modifiers;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get entity(): MethodEntity;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get paramLocalVariableEntity(): VariableEntity | undefined;
+    get isGenerator(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _entity: MethodEntity, _resultLocalVariableEntity: VariableEntity | undefined, _paramLocalVariableEntity: VariableEntity | undefined, _isGenerator: boolean, _sourceLocation: SourceLocation | undefined);
+    update(modifiers: Modifiers, valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement, entity: MethodEntity, resultLocalVariableEntity: VariableEntity | undefined, paramLocalVariableEntity: VariableEntity | undefined): void;
+    clone(): PackageMethodDeclaration;
+}
+export declare class PackageTypeDeclaration {
+    private _modifiers;
+    private _members;
+    private _entity;
+    private _sourceLocation;
+    private _baseType?;
+    readonly kind = NodeKind.PackageTypeDeclaration;
+    get modifiers(): Modifiers;
+    get members(): readonly TypeMemberDeclaration[];
+    get entity(): TypeEntity;
+    get baseType(): TypeEntity | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _members: readonly TypeMemberDeclaration[], _entity: TypeEntity, _sourceLocation: SourceLocation | undefined, _baseType?: TypeEntity | undefined);
+    update(members: readonly TypeMemberDeclaration[], entity: TypeEntity, baseType: TypeEntity | undefined): void;
+    clone(): PackageTypeDeclaration;
+}
+export declare class PackageVariableDeclaration {
+    private _modifiers;
+    private _initializer;
+    private _getter;
+    private _setter;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageVariableDeclaration;
+    get modifiers(): Modifiers;
+    get initializer(): Expression | undefined;
+    get getter(): PackageVariableGetterDeclaration | undefined;
+    get setter(): PackageVariableSetterDeclaration | undefined;
+    get entity(): PackageVariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _initializer: Expression | undefined, _getter: PackageVariableGetterDeclaration | undefined, _setter: PackageVariableSetterDeclaration | undefined, _entity: PackageVariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(initializer: Expression | undefined, getter: PackageVariableGetterDeclaration | undefined, setter: PackageVariableSetterDeclaration | undefined): void;
+    clone(): PackageVariableDeclaration;
+}
+export declare class PackageVariableGetterDeclaration {
+    private _body;
+    private _entity;
+    private _resultLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageVariableGetterDeclaration;
+    get body(): BlockStatement;
+    get entity(): GetterEntity;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _entity: GetterEntity, _resultLocalVariableEntity: VariableEntity | undefined, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): PackageVariableGetterDeclaration;
+}
+export declare class PackageVariableSetterDeclaration {
+    private _body;
+    private _entity;
+    private _paramLocalVariableEntity;
+    private _valueLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageVariableSetterDeclaration;
+    get body(): BlockStatement;
+    get entity(): SetterEntity;
+    get paramLocalVariableEntity(): VariableEntity | undefined;
+    get valueLocalVariableEntity(): VariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _entity: SetterEntity, _paramLocalVariableEntity: VariableEntity | undefined, _valueLocalVariableEntity: VariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): PackageVariableSetterDeclaration;
+}
+export declare class PackageVariantTypeDeclaration {
+    private _modifiers;
+    private _underlyingTypeKind;
+    private _variants;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.PackageVariantTypeDeclaration;
+    get modifiers(): Modifiers;
+    get underlyingTypeKind(): UnderlyingTypeKind;
+    get variants(): readonly VariantDeclaration[];
+    get entity(): VariantTypeEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _underlyingTypeKind: UnderlyingTypeKind, _variants: readonly VariantDeclaration[], _entity: VariantTypeEntity, _sourceLocation: SourceLocation | undefined);
+    update(variants: readonly VariantDeclaration[]): void;
+    clone(): PackageVariantTypeDeclaration;
+}
+export declare const enum UnderlyingTypeKind {
+    Numeric = 0,
+    NonNumeric = 1
+}
+export declare class VariantDeclaration {
+    private _value;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.VariantDeclaration;
+    get value(): Expression | undefined;
+    get entity(): VariantEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_value: Expression | undefined, _entity: VariantEntity, _sourceLocation: SourceLocation | undefined);
+    update(value: Expression | undefined): void;
+    clone(): VariantDeclaration;
+}
+export declare class PrefixUnaryExpression {
+    private _operator;
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.PrefixUnaryExpression;
+    get operator(): PrefixUnaryExpressionOperator;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_operator: PrefixUnaryExpressionOperator, _expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(operator: PrefixUnaryExpressionOperator, expression: Expression): void;
+    clone(): PrefixUnaryExpression;
+}
+export declare class PropertyDeclaration {
+    private _modifiers;
+    private _variableEntity;
+    private _getter;
+    private _setter;
+    private _sourceLocation;
+    readonly kind = NodeKind.PropertyDeclaration;
+    get modifiers(): Modifiers;
+    get variableEntity(): VariableEntity;
+    get getter(): TypeVariableGetterDeclaration;
+    get setter(): TypeVariableSetterDeclaration | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _variableEntity: VariableEntity, _getter: TypeVariableGetterDeclaration, _setter: TypeVariableSetterDeclaration | undefined, _sourceLocation: SourceLocation | undefined);
+    update(variableEntity: VariableEntity, getter: TypeVariableGetterDeclaration, setter: TypeVariableSetterDeclaration | undefined): void;
+    clone(): PropertyDeclaration;
+}
+export declare class ReferenceExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.ReferenceExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): ReferenceExpression;
+}
+export declare class ReturnStatement {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.ReturnStatement;
+    get expression(): Expression | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression | undefined, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression | undefined): void;
+    clone(): ReturnStatement;
+}
+export declare class RunStatement {
+    private _body;
+    private _clauses;
+    private _sourceLocation;
+    readonly kind = NodeKind.RunStatement;
+    get body(): BlockStatement;
+    get clauses(): readonly BlockStatementClause[];
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _clauses: readonly BlockStatementClause[], _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement, clauses: readonly BlockStatementClause[]): void;
+    clone(): RunStatement;
+}
+export declare class SourceFile {
+    private _leadingStatements;
+    private _declarations;
+    private _trailingStatements;
+    private _sourceLocation;
+    readonly kind = NodeKind.SourceFile;
+    get leadingStatements(): readonly Statement[];
+    get declarations(): readonly PackageMemberDeclaration[];
+    get trailingStatements(): readonly Statement[];
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_leadingStatements: readonly Statement[], _declarations: readonly PackageMemberDeclaration[], _trailingStatements: readonly Statement[], _sourceLocation: SourceLocation | undefined);
+    update(leadingStatements: readonly Statement[], declarations: readonly PackageMemberDeclaration[], trailingStatements: readonly Statement[]): void;
+    clone(): SourceFile;
+}
+export declare class SwitchStatement {
+    private _matchExpression;
+    private _caseClauses;
+    private _defaultClauseBody;
+    private _sourceLocation;
+    readonly kind = NodeKind.SwitchStatement;
+    get matchExpression(): Expression;
+    get caseClauses(): readonly CaseClause[];
+    get defaultClauseBody(): BlockStatement | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_matchExpression: Expression, _caseClauses: readonly CaseClause[], _defaultClauseBody: BlockStatement | undefined, _sourceLocation: SourceLocation | undefined);
+    update(matchExpression: Expression, caseClauses: readonly CaseClause[], defaultClauseBody: BlockStatement | undefined): void;
+    clone(): SwitchStatement;
+}
+export declare class CaseClause {
+    private _expressions;
+    private _body;
+    readonly kind = NodeKind.CaseClause;
+    get expressions(): readonly Expression[];
+    get body(): BlockStatement;
+    constructor(_expressions: readonly Expression[], _body: BlockStatement);
+    update(expressions: readonly Expression[], body: BlockStatement): void;
+    clone(): CaseClause;
+}
+export declare class Tag {
+    private _name;
+    private _callArguments;
+    private _sourceLocation;
+    readonly kind = NodeKind.Tag;
+    get name(): Name;
+    get callArguments(): readonly CallArgument[];
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_name: Name, _callArguments: readonly CallArgument[], _sourceLocation: SourceLocation | undefined);
+    update(name: Name, callArguments: readonly CallArgument[]): void;
+    clone(): Tag;
+}
+export declare class TernaryExpression {
+    private _condition;
+    private _firstExpression;
+    private _secondExpression;
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.TernaryExpression;
+    get condition(): Expression;
+    get firstExpression(): Expression;
+    get secondExpression(): Expression;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_condition: Expression, _firstExpression: Expression, _secondExpression: Expression, _type: types.Type, _sourceLocation: SourceLocation | undefined);
+    update(condition: Expression, firstExpression: Expression, secondExpression: Expression): void;
+    clone(): TernaryExpression;
+}
+export declare class TextLiteral {
+    private _value;
+    private _sourceLocation;
+    readonly kind = NodeKind.TextLiteral;
+    get value(): string;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_value: string, _sourceLocation: SourceLocation | undefined);
+    update(value: string): void;
+    clone(): TextLiteral;
+}
+export declare class TextTemplateLiteral {
+    private _elements;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.TextTemplateLiteral;
+    get elements(): readonly (string | Expression)[];
+    get sourceLocation(): SourceLocation | undefined;
+    get loweringOptions(): TextTemplateLiteralLoweringOptions;
+    constructor(_elements: readonly (string | Expression)[], _sourceLocation: SourceLocation | undefined, _loweringOptions?: TextTemplateLiteralLoweringOptions);
+    update(elements: readonly (string | Expression)[], loweringOptions: TextTemplateLiteralLoweringOptions): void;
+    clone(): TextTemplateLiteral;
+}
+export declare class ThisExpression {
+    private _type;
+    private _sourceLocation;
+    readonly kind = NodeKind.ThisExpression;
+    get type(): types.Type;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_type: types.Type, _sourceLocation: SourceLocation | undefined);
+    clone(): ThisExpression;
+}
+export declare class TransactionalExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.TransactionalExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): TransactionalExpression;
+}
+export declare class TransactionalStatement {
+    private _body;
+    private _sourceLocation;
+    readonly kind = NodeKind.TransactionalStatement;
+    get body(): BlockStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TransactionalStatement;
+}
+export declare class TryCatchFinallyStatement {
+    private _body;
+    private _errorParameter;
+    private _catchClauseBody;
+    private _finallyClauseBody;
+    private _sourceLocation;
+    readonly kind = NodeKind.TryCatchFinallyStatement;
+    get body(): BlockStatement;
+    get errorParameter(): VariableEntity | undefined;
+    get catchClauseBody(): BlockStatement | undefined;
+    get finallyClauseBody(): BlockStatement | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _errorParameter: VariableEntity | undefined, _catchClauseBody: BlockStatement | undefined, _finallyClauseBody: BlockStatement | undefined, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement, errorParameter: VariableEntity | undefined, catchClauseBody: BlockStatement | undefined, finallyClauseBody: BlockStatement | undefined): void;
+    clone(): TryCatchFinallyStatement;
+}
+export declare class TypeAccessExpression {
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeAccessExpression;
+    get entity(): TypeEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: TypeEntity, _sourceLocation: SourceLocation | undefined);
+    update(entity: TypeEntity): void;
+    clone(): TypeAccessExpression;
+}
+export declare class TypeConstructorDeclaration {
+    private _valueParameters;
+    private _body;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeConstructorDeclaration;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get entity(): ConstructorEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _entity: ConstructorEntity, _sourceLocation: SourceLocation | undefined);
+    update(valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement): void;
+    clone(): TypeConstructorDeclaration;
+}
+export declare class TypeDereferenceOperatorDeclaration {
+    private _modifiers;
+    private _getter;
+    private _setter;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeDereferenceOperatorDeclaration;
+    get modifiers(): Modifiers;
+    get getter(): TypeDereferencedVariableGetterDeclaration;
+    get setter(): TypeDereferencedVariableSetterDeclaration | undefined;
+    get entity(): DereferenceOperatorEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _getter: TypeDereferencedVariableGetterDeclaration, _setter: TypeDereferencedVariableSetterDeclaration | undefined, _entity: DereferenceOperatorEntity, _sourceLocation: SourceLocation | undefined);
+    update(modifiers: Modifiers, getter: TypeDereferencedVariableGetterDeclaration, setter: TypeDereferencedVariableSetterDeclaration | undefined, entity: DereferenceOperatorEntity): void;
+    clone(): TypeDereferenceOperatorDeclaration;
+}
+export declare class TypeDereferencedVariableGetterDeclaration {
+    private _body;
+    private _entity;
+    private _resultLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeDereferencedVariableGetterDeclaration;
+    get body(): BlockStatement;
+    get entity(): GetterEntity;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _entity: GetterEntity, _resultLocalVariableEntity: VariableEntity | undefined, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TypeDereferencedVariableGetterDeclaration;
+}
+export declare class TypeDereferencedVariableSetterDeclaration {
+    private _body;
+    private _entity;
+    private _paramLocalVariableEntity;
+    private _valueLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeDereferencedVariableSetterDeclaration;
+    get body(): BlockStatement;
+    get entity(): SetterEntity;
+    get paramLocalVariableEntity(): VariableEntity;
+    get valueLocalVariableEntity(): VariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _entity: SetterEntity, _paramLocalVariableEntity: VariableEntity, _valueLocalVariableEntity: VariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TypeDereferencedVariableSetterDeclaration;
+}
+export declare class TypeDestructorDeclaration {
+    private _valueParameters;
+    private _body;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeDestructorDeclaration;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get entity(): DestructorEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _entity: DestructorEntity, _sourceLocation: SourceLocation | undefined);
+    update(valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement): void;
+    clone(): TypeDestructorDeclaration;
+}
+export declare class TypeExtensionDeclaration {
+    private _members;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeExtensionDeclaration;
+    get members(): readonly TypeMemberDeclaration[];
+    get entity(): TypeExtensionEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_members: readonly TypeMemberDeclaration[], _entity: TypeExtensionEntity, _sourceLocation: SourceLocation | undefined);
+    update(members: readonly TypeMemberDeclaration[]): void;
+    clone(): TypeExtensionDeclaration;
+}
+export declare class TypeIndexedGetterDeclaration {
+    private _body;
+    private _entity;
+    private _resultLocalVariableEntity;
+    private _paramVLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeIndexedGetterDeclaration;
+    get body(): BlockStatement;
+    get entity(): GetterEntity;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get paramLocalVariableEntity(): VariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _entity: GetterEntity, _resultLocalVariableEntity: VariableEntity | undefined, _paramVLocalVariableEntity: VariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TypeIndexedGetterDeclaration;
+}
+export declare class TypeIndexedSetterDeclaration {
+    private _body;
+    private _entity;
+    private _paramLocalVariableEntity;
+    private _valueLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeIndexedSetterDeclaration;
+    get body(): BlockStatement;
+    get entity(): SetterEntity;
+    get paramLocalVariableEntity(): VariableEntity;
+    get valueLocalVariableEntity(): VariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _entity: SetterEntity, _paramLocalVariableEntity: VariableEntity, _valueLocalVariableEntity: VariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TypeIndexedSetterDeclaration;
+}
+export declare class TypeIndexerDeclaration {
+    private _modifiers;
+    private _valueParameters;
+    private _getter;
+    private _setter;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeIndexerDeclaration;
+    get modifiers(): Modifiers;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get getter(): TypeIndexedGetterDeclaration | undefined;
+    get setter(): TypeIndexedSetterDeclaration | undefined;
+    get entity(): IndexerEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _valueParameters: readonly ValueParameterDeclaration[], _getter: TypeIndexedGetterDeclaration | undefined, _setter: TypeIndexedSetterDeclaration | undefined, _entity: IndexerEntity, _sourceLocation: SourceLocation | undefined);
+    update(modifiers: Modifiers, valueParameters: readonly ValueParameterDeclaration[], getter: TypeIndexedGetterDeclaration | undefined, setter: TypeIndexedSetterDeclaration | undefined, entity: IndexerEntity): void;
+    clone(): TypeIndexerDeclaration;
+}
+export declare class TypeMethodAccessExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _method;
+    private _isCallee;
+    private _sourceLocation;
+    private _loweringOptions;
+    readonly kind = NodeKind.TypeMethodAccessExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get method(): AccessedMethod;
+    get isCallee(): boolean;
+    get loweringOptions(): MethodAccessLoweringOptions;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _method: AccessedMethod, _isCallee: boolean, _sourceLocation: SourceLocation | undefined, _loweringOptions?: MethodAccessLoweringOptions);
+    update(expression: Expression, isOptionalChaining: boolean, method: AccessedMethod, loweringOptions: MethodAccessLoweringOptions): void;
+    clone(): TypeMethodAccessExpression;
+}
+export declare class TypeMethodDeclaration {
+    private _modifiers;
+    private _valueParameters;
+    private _body;
+    private _entity;
+    private _resultLocalVariableEntity;
+    private _isGenerator;
+    private _isComputed;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeMethodDeclaration;
+    get modifiers(): Modifiers;
+    get valueParameters(): readonly ValueParameterDeclaration[];
+    get body(): BlockStatement;
+    get entity(): TypeMethodEntity;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get isGenerator(): boolean;
+    get isComputed(): ComputedTypeMethodInfo | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _valueParameters: readonly ValueParameterDeclaration[], _body: BlockStatement, _entity: TypeMethodEntity, _resultLocalVariableEntity: VariableEntity | undefined, _isGenerator: boolean, _isComputed: ComputedTypeMethodInfo | undefined, _sourceLocation: SourceLocation | undefined);
+    update(modifiers: Modifiers, valueParameters: readonly ValueParameterDeclaration[], body: BlockStatement, entity: TypeMethodEntity, isComputed: ComputedTypeMethodInfo | undefined): void;
+    clone(): TypeMethodDeclaration;
+}
+export type ComputedTypeMethodInfo = {
+    readonly key: Expression;
+};
+export declare class TypeVariableAccessExpression {
+    private _expression;
+    private _isOptionalChaining;
+    private _variable;
+    private _access;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeVariableAccessExpression;
+    get expression(): Expression;
+    get isOptionalChaining(): boolean;
+    get variable(): AccessedVariable;
+    get access(): variableAccess.VariableAccess;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _isOptionalChaining: boolean, _variable: AccessedVariable, _access: variableAccess.VariableAccess, _sourceLocation: SourceLocation | undefined);
+    static get(expression: Expression, isOptionalChaining: boolean, variable: AccessedVariable | VariableEntity, sourceLocation?: SourceLocation): TypeVariableAccessExpression;
+    static set(expression: Expression, isOptionalChaining: boolean, variable: AccessedVariable | VariableEntity, sourceLocation?: SourceLocation): TypeVariableAccessExpression;
+    update(expression: Expression, isOptionalChaining: boolean, variable: AccessedVariable, access: variableAccess.VariableAccess): void;
+    clone(): TypeVariableAccessExpression;
+}
+export declare class TypeVariableDeclaration {
+    private _modifiers;
+    private _initializer;
+    private _getter;
+    private _setter;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeVariableDeclaration;
+    get modifiers(): Modifiers;
+    get initializer(): Expression | undefined;
+    get getter(): TypeVariableGetterDeclaration | undefined;
+    get setter(): TypeVariableSetterDeclaration | undefined;
+    get entity(): TypeVariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_modifiers: Modifiers, _initializer: Expression | undefined, _getter: TypeVariableGetterDeclaration | undefined, _setter: TypeVariableSetterDeclaration | undefined, _entity: TypeVariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(modifiers: Modifiers, initializer: Expression | undefined, getter: TypeVariableGetterDeclaration | undefined, setter: TypeVariableSetterDeclaration | undefined): void;
+    clone(): TypeVariableDeclaration;
+}
+export declare class TypeVariableGetterDeclaration {
+    private _body;
+    private _resultLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeVariableGetterDeclaration;
+    get body(): BlockStatement;
+    get resultLocalVariableEntity(): VariableEntity | undefined;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _resultLocalVariableEntity: VariableEntity | undefined, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TypeVariableGetterDeclaration;
+}
+export declare class TypeVariableSetterDeclaration {
+    private _body;
+    private _paramLocalVariableEntity;
+    private _valueLocalVariableEntity;
+    private _sourceLocation;
+    readonly kind = NodeKind.TypeVariableSetterDeclaration;
+    get body(): BlockStatement;
+    get paramLocalVariableEntity(): VariableEntity | undefined;
+    get valueLocalVariableEntity(): VariableEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _paramLocalVariableEntity: VariableEntity | undefined, _valueLocalVariableEntity: VariableEntity, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): TypeVariableSetterDeclaration;
+}
+export declare class UnobservableExpression {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.UnobservableExpression;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): UnobservableExpression;
+}
+export declare class UnobservableStatement {
+    private _body;
+    private _sourceLocation;
+    readonly kind = NodeKind.UnobservableStatement;
+    get body(): BlockStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_body: BlockStatement, _sourceLocation: SourceLocation | undefined);
+    update(body: BlockStatement): void;
+    clone(): UnobservableStatement;
+}
+export declare class ValueParameterDeclaration {
+    private _entity;
+    private _defaultValue;
+    /**
+     * ...param
+     */
+    private _isRest;
+    private _sourceLocation;
+    readonly kind = NodeKind.ValueParameterDeclaration;
+    get entity(): VariableEntity;
+    get defaultValue(): Expression | undefined;
+    get isRest(): boolean;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_entity: VariableEntity, _defaultValue: Expression | undefined, 
+    /**
+     * ...param
+     */
+    _isRest: boolean, _sourceLocation: SourceLocation | undefined);
+    update(defaultValue: Expression | undefined): void;
+    clone(): ValueParameterDeclaration;
+}
+export declare class VariableAccessExpression {
+    private _variable;
+    private _access;
+    private _sourceLocation;
+    readonly kind = NodeKind.VariableAccessExpression;
+    get variable(): AccessedVariable;
+    get access(): variableAccess.VariableAccess;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_variable: AccessedVariable, _access: variableAccess.VariableAccess, _sourceLocation: SourceLocation | undefined);
+    static get(variable: AccessedVariable | VariableEntity): VariableAccessExpression;
+    static set(variable: AccessedVariable | VariableEntity): VariableAccessExpression;
+    update(variable: AccessedVariable, access: variableAccess.VariableAccess): void;
+    clone(): VariableAccessExpression;
+}
+export declare class VariantAccessExpression {
+    private _typeAccess;
+    private _entity;
+    private _sourceLocation;
+    readonly kind = NodeKind.VariantAccessExpression;
+    get typeAccess(): TypeAccessExpression;
+    get entity(): VariantEntity;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_typeAccess: TypeAccessExpression, _entity: VariantEntity, _sourceLocation: SourceLocation | undefined);
+    update(typeAccess: TypeAccessExpression, entity: VariantEntity): void;
+    clone(): VariantAccessExpression;
+}
+export declare class WhileStatement {
+    private _label;
+    private _condition;
+    private _body;
+    private _sourceLocation;
+    readonly kind = NodeKind.WhileStatement;
+    get label(): string | undefined;
+    get condition(): Expression;
+    get body(): BlockStatement;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_label: string | undefined, _condition: Expression, _body: BlockStatement, _sourceLocation: SourceLocation | undefined);
+    update(condition: Expression, body: BlockStatement): void;
+    clone(): WhileStatement;
+}
+export declare class YieldStatement {
+    private _expression;
+    private _sourceLocation;
+    readonly kind = NodeKind.YieldStatement;
+    get expression(): Expression;
+    get sourceLocation(): SourceLocation | undefined;
+    constructor(_expression: Expression, _sourceLocation: SourceLocation | undefined);
+    update(expression: Expression): void;
+    clone(): YieldStatement;
+}
+export declare const enum NodeKind {
+    AsExpression = 0,
+    AssertionExpression = 1,
+    AssumptionExpression = 2,
+    AssignmentStatement = 3,
+    BinaryExpression = 4,
+    BlockStatement = 5,
+    BooleanLiteral = 6,
+    BreakLoopStatement = 7,
+    CallArgument = 8,
+    CallExpression = 9,
+    CaseClause = 10,
+    CharLiteral = 11,
+    ContinueLoopStatement = 12,
+    DisposeStatement = 13,
+    RunStatement = 14,
+    NoneLiteral = 15,
+    EmptyStatement = 16,
+    ErrorStatement = 17,
+    ExpressionStatement = 18,
+    FinallyClause = 19,
+    ForStatement = 20,
+    PackageConstructorDeclaration = 21,
+    PackageEntryPointDeclaration = 22,
+    PackageMethodDeclaration = 23,
+    PackageTypeDeclaration = 24,
+    PackageVariableDeclaration = 25,
+    PackageVariableGetterDeclaration = 26,
+    PackageVariableSetterDeclaration = 27,
+    PackageVariantTypeDeclaration = 28,
+    IfStatement = 29,
+    IndexedAccessExpression = 30,
+    IntegerLiteral = 31,
+    HelperMethodCallExpression = 32,
+    IsExpression = 33,
+    NestedMethodDeclaration = 34,
+    NestedMethodDeclarationStatement = 35,
+    LocalVariableDeclaration = 36,
+    LocalVariableDeclarationStatement = 37,
+    NotExpression = 38,
+    NumericLiteral = 39,
+    OnErrorClause = 40,
+    MethodLiteral = 41,
+    PrefixUnaryExpression = 42,
+    MeasureLiteral = 43,
+    ReferenceExpression = 44,
+    LoopStatement = 45,
+    ReturnStatement = 46,
+    SourceFile = 47,
+    TextLiteral = 48,
+    TextTemplateLiteral = 49,
+    TypeConstructorDeclaration = 50,
+    TypeDestructorDeclaration = 51,
+    TypeExtensionDeclaration = 52,
+    TypeIndexerDeclaration = 53,
+    TypeIndexedGetterDeclaration = 54,
+    TypeIndexedSetterDeclaration = 55,
+    TypeMethodDeclaration = 56,
+    TypeVariableDeclaration = 57,
+    TypeVariableGetterDeclaration = 58,
+    TypeVariableSetterDeclaration = 59,
+    SwitchStatement = 60,
+    Tag = 61,
+    TernaryExpression = 62,
+    ThisExpression = 63,
+    ValueParameterDeclaration = 64,
+    VariantDeclaration = 65,
+    WhileStatement = 66,
+    YieldStatement = 67,
+    ArrayLiteral = 68,
+    TypeAccessExpression = 69,
+    VariableAccessExpression = 70,
+    MethodAccessExpression = 71,
+    ImplicitVariantAccessExpression = 72,
+    VariantAccessExpression = 73,
+    TypeVariableAccessExpression = 74,
+    TypeMethodAccessExpression = 75,
+    PropertyDeclaration = 76,
+    ConstructorCallExpression = 77,
+    TryCatchFinallyStatement = 78,
+    InlineJsExpression = 79,
+    AssignmentExpression = 80,
+    CommaExpression = 81,
+    SuperExpression = 82,
+    BaseConstructorCallExpression = 83,
+    JsImportSpecifier = 84,
+    JsIndexedAccessExpression = 85,
+    EsModuleImportDirectiveStatement = 86,
+    CjsModuleImportDirectiveStatement = 87,
+    JsObjectLiteral = 88,
+    JsObjectLiteralProperty = 89,
+    JsPropertyAccessExpression = 90,
+    JsFunctionLiteral = 91,
+    ImplicitConversionExpression = 92,
+    JsTypeOfExpression = 93,
+    JsInstanceOfExpression = 94,
+    UnobservableStatement = 95,
+    TransactionalStatement = 96,
+    TransactionalExpression = 97,
+    UnobservableExpression = 98,
+    JsIdentifierExpression = 99,
+    DereferenceExpression = 100,
+    BaseExpression = 101,
+    OwnConstructorCallExpression = 102,
+    TypeDereferenceOperatorDeclaration = 103,
+    TypeDereferencedVariableGetterDeclaration = 104,
+    TypeDereferencedVariableSetterDeclaration = 105,
+    JsNamespaceDestructuringStatement = 106
+}
+export declare const enum PrefixUnaryExpressionOperator {
+    Plus = 0,
+    Minus = 1
+}
+export declare const enum BinaryExpressionOperator {
+    Add = 0,
+    Subtract = 1,
+    Multiply = 2,
+    Divide = 3,
+    IntegerDivide = 4,
+    Equals = 5,
+    NotEquals = 6,
+    LessThan = 7,
+    GreaterThan = 8,
+    LessThanEquals = 9,
+    GreaterThanEquals = 10,
+    Or = 11,
+    And = 12,
+    Xor = 13,
+    QuestionQuestion = 14,
+    Modulo = 15
+}