@artel/artc 0.6.25191

package/build/types/emitter/Transformer.d.ts

@@ -0,0 +1,282 @@
+import type { DereferenceOperatorEntity, IndexerEntity, VariableEntity } from '../entities/index.js';
+import { DebugStack } from './DebugStack.js';
+import { blockStatementTransformationResult, expressionTransformationResult, packageMemberDeclarationTransformationResult, simpleTransformationResult, statementTransformationResult, typeAccessExpressionTransformationResult, typeMemberDeclarationTransformationResult } from './Internal.js';
+import { TransformationContinuationAction } from './TransformationContinuationAction.js';
+import * as ir from './ir/index.js';
+export declare class Transformer {
+    readonly config: TransformationConfig;
+    protected readonly _debugStack: DebugStack;
+    private _hoistedLocalVariables;
+    private _transformingContainer;
+    get transformingContainer(): TransformingContainer | undefined;
+    constructor(config: TransformationConfig);
+    transform(sourceFile: ir.SourceFile): void;
+    transformPackageMemberDeclaration(declaration: ir.PackageMemberDeclaration): readonly ir.PackageMemberDeclaration[];
+    transformPackageConstructorDeclarationChildren(declaration: ir.PackageConstructorDeclaration): void;
+    transformBlockStatement(statement: ir.BlockStatement): ir.BlockStatement;
+    transformStatement(statement: ir.Statement): readonly ir.Statement[];
+    transformAssignmentStatementChildren(statement: ir.AssignmentStatement): void;
+    transformBlockStatementChildren(statement: ir.BlockStatement): void;
+    transformBlockStatementClause(clause: ir.BlockStatementClause): ir.BlockStatementClause;
+    transformBreakLoopStatementChildren(_statement: ir.BreakLoopStatement): void;
+    transformContinueLoopStatementChildren(_statement: ir.ContinueLoopStatement): void;
+    transformDisposeStatementChildren(statement: ir.DisposeStatement): void;
+    transformRunStatementChildren(statement: ir.RunStatement): void;
+    transformEmptyStatementChildren(_statement: ir.EmptyStatement): void;
+    transformErrorStatementChildren(statement: ir.ErrorStatement): void;
+    transformExpressionStatementChildren(statement: ir.ExpressionStatement): void;
+    transformForStatementChildren(statement: ir.ForStatement): void;
+    transformIfStatementChildren(statement: ir.IfStatement): void;
+    transformNestedMethodDeclarationStatementChildren(statement: ir.NestedMethodDeclarationStatement): void;
+    transformNestedMethodDeclaration(declaration: ir.NestedMethodDeclaration): ir.NestedMethodDeclaration;
+    transformValueParameterDeclaration(declaration: ir.ValueParameterDeclaration): ir.ValueParameterDeclaration;
+    transformNodeWithSimpleTransformationResult<T>(node: T, transform: (node: T) => simpleTransformationResult.Type<T> | undefined): {
+        transformedNode: T;
+        action: TransformationContinuationAction;
+    };
+    transformLocalVariableDeclarationStatementChildren(statement: ir.LocalVariableDeclarationStatement): void;
+    transformLocalVariableDeclaration(declaration: ir.LocalVariableDeclaration): ir.LocalVariableDeclaration;
+    transformUnobservableStatementChildren(statement: ir.UnobservableStatement): void;
+    transformLoopStatementChildren(statement: ir.LoopStatement): void;
+    transformReturnStatementChildren(statement: ir.ReturnStatement): void;
+    transformSwitchStatementChildren(statement: ir.SwitchStatement): void;
+    transformCaseClause(caseClause: ir.CaseClause): ir.CaseClause;
+    transformTransactionalStatementChildren(statement: ir.TransactionalStatement): void;
+    transformWhileStatementChildren(statement: ir.WhileStatement): void;
+    transformYieldStatementChildren(statement: ir.YieldStatement): void;
+    transformTryCatchFinallyStatementChildren(statement: ir.TryCatchFinallyStatement): void;
+    transformEsModuleImportDirectiveStatementChildren(_statement: ir.EsModuleImportDirectiveStatement): void;
+    transformCjsModuleImportDirectiveStatementChildren(_statement: ir.CjsModuleImportDirectiveStatement): void;
+    transformJsNamespaceDestructuringStatementChildren(_statement: ir.JsNamespaceDestructuringStatement): void;
+    transformPackageEntryPointDeclarationChildren(declaration: ir.PackageEntryPointDeclaration): void;
+    transformPackageMethodDeclarationChildren(declaration: ir.PackageMethodDeclaration): void;
+    transformPackageTypeDeclarationChildren(declaration: ir.PackageTypeDeclaration): void;
+    transformTypeMemberDeclaration(declaration: ir.TypeMemberDeclaration): readonly ir.TypeMemberDeclaration[];
+    transformPropertyDeclarationChildren(declaration: ir.PropertyDeclaration): void;
+    transformTypeConstructorDeclarationChildren(declaration: ir.TypeConstructorDeclaration): void;
+    transformTypeDestructorDeclarationChildren(declaration: ir.TypeDestructorDeclaration): void;
+    transformTypeIndexerDeclarationChildren(declaration: ir.TypeIndexerDeclaration): void;
+    transformTypeDereferenceOperatorDeclarationChildren(declaration: ir.TypeDereferenceOperatorDeclaration): void;
+    transformTypeIndexedGetterDeclaration(declaration: ir.TypeIndexedGetterDeclaration, indexer: IndexerEntity): ir.TypeIndexedGetterDeclaration;
+    transformTypeIndexedSetterDeclaration(declaration: ir.TypeIndexedSetterDeclaration, indexer: IndexerEntity): ir.TypeIndexedSetterDeclaration;
+    transformTypeDereferencedVariableGetterDeclaration(declaration: ir.TypeDereferencedVariableGetterDeclaration, indexer: DereferenceOperatorEntity): ir.TypeDereferencedVariableGetterDeclaration;
+    transformTypeDereferencedVariableSetterDeclaration(declaration: ir.TypeDereferencedVariableSetterDeclaration, indexer: DereferenceOperatorEntity): ir.TypeDereferencedVariableSetterDeclaration;
+    transformTypeMethodDeclarationChildren(declaration: ir.TypeMethodDeclaration): void;
+    transformTypeVariableDeclarationChildren(declaration: ir.TypeVariableDeclaration): void;
+    transformTypeVariableGetterDeclaration(declaration: ir.TypeVariableGetterDeclaration, variable: VariableEntity): ir.TypeVariableGetterDeclaration;
+    transformTypeVariableSetterDeclaration(declaration: ir.TypeVariableSetterDeclaration, variable: VariableEntity): ir.TypeVariableSetterDeclaration;
+    transformPackageVariableDeclarationChildren(declaration: ir.PackageVariableDeclaration): void;
+    transformPackageVariableGetterDeclaration(declaration: ir.PackageVariableGetterDeclaration): ir.PackageVariableGetterDeclaration;
+    transformPackageVariableSetterDeclaration(declaration: ir.PackageVariableSetterDeclaration): ir.PackageVariableSetterDeclaration;
+    transformPackageVariantTypeDeclarationChildren(declaration: ir.PackageVariantTypeDeclaration): void;
+    transformVariantDeclaration(declaration: ir.VariantDeclaration): ir.VariantDeclaration;
+    transformTypeExtensionDeclarationChildren(declaration: ir.TypeExtensionDeclaration): void;
+    transformExpression(expression: ir.Expression): ir.Expression;
+    transformAsExpressionChildren(expression: ir.AsExpression): void;
+    transformAssertionExpressionChildren(expression: ir.AssertionExpression): void;
+    transformAssumptionExpressionChildren(expression: ir.AssumptionExpression): void;
+    transformBinaryExpressionChildren(expression: ir.BinaryExpression): void;
+    transformBooleanLiteralChildren(_expression: ir.BooleanLiteral): void;
+    transformCallExpressionChildren(expression: ir.CallExpression): void;
+    transformCallArguments(callArguments: ir.CallArguments): ir.CallArguments;
+    transformCharLiteralChildren(_expression: ir.CharLiteral): void;
+    transformNoneLiteralChildren(_expression: ir.NoneLiteral): void;
+    transformIndexedAccessExpressionChildren(expression: ir.IndexedAccessExpression): void;
+    transformIntegerLiteralChildren(_expression: ir.IntegerLiteral): void;
+    transformHelperMethodCallExpressionChildren(expression: ir.HelperMethodCallExpression): void;
+    transformIsExpressionChildren(expression: ir.IsExpression): void;
+    transformUnobservableExpressionChildren(expression: ir.UnobservableExpression): void;
+    transformNotExpressionChildren(expression: ir.NotExpression): void;
+    transformNumericLiteralChildren(_expression: ir.NumericLiteral): void;
+    transformMethodLiteralChildren(expression: ir.MethodLiteral): void;
+    transformPrefixUnaryExpressionChildren(expression: ir.PrefixUnaryExpression): void;
+    transformMeasureLiteralChildren(_expression: ir.MeasureLiteral): void;
+    transformReferenceExpressionChildren(expression: ir.ReferenceExpression): void;
+    transformTextLiteralChildren(_expression: ir.TextLiteral): void;
+    transformTextTemplateLiteralChildren(expression: ir.TextTemplateLiteral): void;
+    transformTernaryExpressionChildren(expression: ir.TernaryExpression): void;
+    transformThisExpressionChildren(_expression: ir.ThisExpression): void;
+    transformBaseExpressionChildren(_expression: ir.BaseExpression): void;
+    transformTransactionalExpressionChildren(expression: ir.TransactionalExpression): void;
+    transformArrayLiteralChildren(expression: ir.ArrayLiteral): void;
+    transformTypeAccessExpressionChildren(_expression: ir.TypeAccessExpression): void;
+    transformVariableAccessExpressionChildren(_expression: ir.VariableAccessExpression): void;
+    transformMethodAccessExpressionChildren(_expression: ir.MethodAccessExpression): void;
+    transformImplicitVariantAccessExpressionChildren(_expression: ir.ImplicitVariantAccessExpression): void;
+    transformVariantAccessExpressionChildren(expression: ir.VariantAccessExpression): void;
+    transformTypeAccessExpression(expression: ir.TypeAccessExpression): ir.TypeAccessExpression;
+    transformInstanceVariableAccessExpressionChildren(expression: ir.TypeVariableAccessExpression): void;
+    transformTypeMethodAccessExpressionChildren(expression: ir.TypeMethodAccessExpression): void;
+    transformConstructorCallExpressionChildren(expression: ir.ConstructorCallExpression): void;
+    transformInlineJsExpressionChildren(_expression: ir.InlineJsExpression): void;
+    transformAssignmentExpressionChildren(expression: ir.AssignmentExpression): void;
+    transformCommaExpressionChildren(expression: ir.CommaExpression): void;
+    transformOwnConstructorCallExpressionChildren(expression: ir.OwnConstructorCallExpression): void;
+    transformBaseConstructorCallExpressionChildren(expression: ir.BaseConstructorCallExpression): void;
+    transformJsIndexedAccessExpressionChildren(expression: ir.JsIndexedAccessExpression): void;
+    transformJsObjectLiteralChildren(expression: ir.JsObjectLiteral): void;
+    transformJsPropertyAccessExpressionChildren(expression: ir.JsPropertyAccessExpression): void;
+    transformJsFunctionLiteralChildren(expression: ir.JsFunctionLiteral): void;
+    transformImplicitConversionExpressionChildren(expression: ir.ImplicitConversionExpression): void;
+    transformJsTypeOfExpressionChildren(expression: ir.JsTypeOfExpression): void;
+    transformJsInstanceOfExpressionChildren(expression: ir.JsInstanceOfExpression): void;
+    transformJsIdentifierExpressionChildren(_expression: ir.JsIdentifierExpression): void;
+    transformDereferenceExpressionChildren(expression: ir.DereferenceExpression): void;
+    transformJsObjectLiteralProperty(property: ir.JsObjectLiteralProperty): ir.JsObjectLiteralProperty;
+    private transformArrayWithErrorBoundary;
+    private createLocalVariableDeclarations;
+    private withTransformingContainer;
+}
+interface TransformationConfig {
+    transformAssertionExpression?(expression: ir.AssertionExpression): expressionTransformationResult.Type;
+    transformAssumptionExpression?(expression: ir.AssumptionExpression): expressionTransformationResult.Type;
+    transformAsExpression?(expression: ir.AsExpression): expressionTransformationResult.Type;
+    transformBinaryExpression?(expression: ir.BinaryExpression): expressionTransformationResult.Type;
+    transformCallExpression?(expression: ir.CallExpression): expressionTransformationResult.Type;
+    transformIndexedAccessExpression?(expression: ir.IndexedAccessExpression): expressionTransformationResult.Type;
+    transformIsExpression?(expression: ir.IsExpression): expressionTransformationResult.Type;
+    transformUnobservableExpression?(expression: ir.UnobservableExpression): expressionTransformationResult.Type;
+    transformNotExpression?(expression: ir.NotExpression): expressionTransformationResult.Type;
+    transformMethodLiteral?(expression: ir.MethodLiteral): expressionTransformationResult.Type;
+    transformPrefixUnaryExpression?(expression: ir.PrefixUnaryExpression): expressionTransformationResult.Type;
+    transformReferenceExpression?(expression: ir.ReferenceExpression): expressionTransformationResult.Type;
+    transformTernaryExpression?(expression: ir.TernaryExpression): expressionTransformationResult.Type;
+    transformArrayLiteral?(expression: ir.ArrayLiteral): expressionTransformationResult.Type;
+    transformTypeAccessExpression?(expression: ir.TypeAccessExpression): typeAccessExpressionTransformationResult.TypeAccessExpressionTransformationResult;
+    transformVariableAccessExpression?(expression: ir.VariableAccessExpression): expressionTransformationResult.Type;
+    transformMethodAccessExpression?(expression: ir.MethodAccessExpression): expressionTransformationResult.Type;
+    transformImplicitVariantAccessExpression?(expression: ir.ImplicitVariantAccessExpression): expressionTransformationResult.Type;
+    transformVariantAccessExpression?(expression: ir.VariantAccessExpression): expressionTransformationResult.Type;
+    transformTypeVariableAccessExpression?(expression: ir.TypeVariableAccessExpression): expressionTransformationResult.Type;
+    transformTypeMethodAccessExpression?(expression: ir.TypeMethodAccessExpression): expressionTransformationResult.Type;
+    transformTextTemplateLiteral?(expression: ir.TextTemplateLiteral): expressionTransformationResult.Type;
+    transformTransactionalExpression?(expression: ir.TransactionalExpression): expressionTransformationResult.Type;
+    transformCharLiteral?(expression: ir.CharLiteral): expressionTransformationResult.Type;
+    transformTextLiteral?(expression: ir.TextLiteral): expressionTransformationResult.Type;
+    transformBooleanLiteral?(expression: ir.BooleanLiteral): expressionTransformationResult.Type;
+    transformIntegerLiteral?(expression: ir.IntegerLiteral): expressionTransformationResult.Type;
+    transformNumericLiteral?(expression: ir.NumericLiteral): expressionTransformationResult.Type;
+    transformMeasureLiteral?(expression: ir.MeasureLiteral): expressionTransformationResult.Type;
+    transformNoneLiteral?(expression: ir.NoneLiteral): expressionTransformationResult.Type;
+    transformThisExpression?(expression: ir.ThisExpression): expressionTransformationResult.Type;
+    transformBaseExpression?(expression: ir.BaseExpression): expressionTransformationResult.Type;
+    transformHelperMethodCallExpression?(expression: ir.HelperMethodCallExpression): expressionTransformationResult.Type;
+    transformConstructorCallExpression?(expression: ir.ConstructorCallExpression): expressionTransformationResult.Type;
+    transformInlineJsExpression?(expression: ir.InlineJsExpression): expressionTransformationResult.Type;
+    transformAssignmentExpression?(expression: ir.AssignmentExpression): expressionTransformationResult.Type;
+    transformCommaExpression?(expression: ir.CommaExpression): expressionTransformationResult.Type;
+    transformOwnConstructorCallExpression?(expression: ir.OwnConstructorCallExpression): expressionTransformationResult.Type;
+    transformBaseConstructorCallExpression?(expression: ir.BaseConstructorCallExpression): expressionTransformationResult.Type;
+    transformJsIndexedAccessExpression?(expression: ir.JsIndexedAccessExpression): expressionTransformationResult.Type;
+    transformJsObjectLiteral?(expression: ir.JsObjectLiteral): expressionTransformationResult.Type;
+    transformJsPropertyAccessExpression?(expression: ir.JsPropertyAccessExpression): expressionTransformationResult.Type;
+    transformJsFunctionLiteral?(expression: ir.JsFunctionLiteral): expressionTransformationResult.Type;
+    transformImplicitConversionExpression?(expression: ir.ImplicitConversionExpression): expressionTransformationResult.Type;
+    transformJsTypeOfExpression?(expression: ir.JsTypeOfExpression): expressionTransformationResult.Type;
+    transformJsInstanceOfExpression?(expression: ir.JsInstanceOfExpression): expressionTransformationResult.Type;
+    transformJsIdentifierExpression?(expression: ir.JsIdentifierExpression): expressionTransformationResult.Type;
+    transformDereferenceExpression?(expression: ir.DereferenceExpression): expressionTransformationResult.Type;
+    transformBlockStatement?(statement: ir.BlockStatement): blockStatementTransformationResult.Type;
+    transformBreakLoopStatement?(statement: ir.BreakLoopStatement): statementTransformationResult.Type;
+    transformContinueLoopStatement?(statement: ir.ContinueLoopStatement): statementTransformationResult.Type;
+    transformDisposeStatement?(statement: ir.DisposeStatement): statementTransformationResult.Type;
+    transformRunStatement?(statement: ir.RunStatement): statementTransformationResult.Type;
+    transformEmptyStatement?(statement: ir.EmptyStatement): statementTransformationResult.Type;
+    transformErrorStatement?(statement: ir.ErrorStatement): statementTransformationResult.Type;
+    transformExpressionStatement?(statement: ir.ExpressionStatement): statementTransformationResult.Type;
+    transformForStatement?(statement: ir.ForStatement): statementTransformationResult.Type;
+    transformIfStatement?(statement: ir.IfStatement): statementTransformationResult.Type;
+    transformNestedMethodDeclarationStatement?(statement: ir.NestedMethodDeclarationStatement): statementTransformationResult.Type;
+    transformLocalVariableDeclarationStatement?(statement: ir.LocalVariableDeclarationStatement): statementTransformationResult.Type;
+    transformUnobservableStatement?(statement: ir.UnobservableStatement): statementTransformationResult.Type;
+    transformLoopStatement?(statement: ir.LoopStatement): statementTransformationResult.Type;
+    transformReturnStatement?(statement: ir.ReturnStatement): statementTransformationResult.Type;
+    transformSwitchStatement?(statement: ir.SwitchStatement): statementTransformationResult.Type;
+    transformTransactionalStatement?(statement: ir.TransactionalStatement): statementTransformationResult.Type;
+    transformWhileStatement?(statement: ir.WhileStatement): statementTransformationResult.Type;
+    transformYieldStatement?(statement: ir.YieldStatement): statementTransformationResult.Type;
+    transformAssignmentStatement?(statement: ir.AssignmentStatement): statementTransformationResult.Type;
+    transformTryCatchFinallyStatement?(statement: ir.TryCatchFinallyStatement): statementTransformationResult.Type;
+    transformEsModuleImportDirectiveStatement?(statement: ir.EsModuleImportDirectiveStatement): statementTransformationResult.Type;
+    transformCjsModuleImportDirectiveStatement?(statement: ir.CjsModuleImportDirectiveStatement): statementTransformationResult.Type;
+    transformJsNamespaceDestructuringStatement?(statement: ir.JsNamespaceDestructuringStatement): statementTransformationResult.Type;
+    transformPackageConstructorDeclaration?(declaration: ir.PackageConstructorDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformPackageEntryPointDeclaration?(declaration: ir.PackageEntryPointDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformPackageMethodDeclaration?(declaration: ir.PackageMethodDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformPackageTypeDeclaration?(declaration: ir.PackageTypeDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformPackageVariableDeclaration?(declaration: ir.PackageVariableDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformPackageVariableGetterDeclaration?(declaration: ir.PackageVariableGetterDeclaration): simpleTransformationResult.Type<ir.PackageVariableGetterDeclaration>;
+    transformPackageVariableSetterDeclaration?(declaration: ir.PackageVariableSetterDeclaration): simpleTransformationResult.Type<ir.PackageVariableSetterDeclaration>;
+    transformPackageVariantTypeDeclaration?(declaration: ir.PackageVariantTypeDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformTypeExtensionDeclaration?(declaration: ir.TypeExtensionDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformTypeVariableDeclaration?(declaration: ir.TypeVariableDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeMethodDeclaration?(declaration: ir.TypeMethodDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeConstructorDeclaration?(declaration: ir.TypeConstructorDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeDestructorDeclaration?(declaration: ir.TypeDestructorDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeIndexerDeclaration?(declaration: ir.TypeIndexerDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeDereferenceOperatorDeclaration?(declaration: ir.TypeDereferenceOperatorDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformPropertyDeclaration?(declaration: ir.PropertyDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformNestedMethodDeclaration?(declaration: ir.NestedMethodDeclaration): simpleTransformationResult.Type<ir.NestedMethodDeclaration>;
+    transformLocalVariableDeclaration?(declaration: ir.LocalVariableDeclaration): simpleTransformationResult.Type<ir.LocalVariableDeclaration>;
+    transformValueParameterDeclaration?(declaration: ir.ValueParameterDeclaration): simpleTransformationResult.Type<ir.ValueParameterDeclaration>;
+    transformCaseClause?(declaration: ir.CaseClause): simpleTransformationResult.Type<ir.CaseClause>;
+    transformTypeIndexedGetterDeclaration?(declaration: ir.TypeIndexedGetterDeclaration): simpleTransformationResult.Type<ir.TypeIndexedGetterDeclaration>;
+    transformTypeIndexedSetterDeclaration?(declaration: ir.TypeIndexedSetterDeclaration): simpleTransformationResult.Type<ir.TypeIndexedSetterDeclaration>;
+    transformTypeDereferencedVariableGetterDeclaration?(declaration: ir.TypeDereferencedVariableGetterDeclaration): simpleTransformationResult.Type<ir.TypeDereferencedVariableGetterDeclaration>;
+    transformTypeDereferencedVariableSetterDeclaration?(declaration: ir.TypeDereferencedVariableSetterDeclaration): simpleTransformationResult.Type<ir.TypeDereferencedVariableSetterDeclaration>;
+    transformTypeVariableGetterDeclaration?(declaration: ir.TypeVariableGetterDeclaration): simpleTransformationResult.Type<ir.TypeVariableGetterDeclaration>;
+    transformTypeVariableSetterDeclaration?(declaration: ir.TypeVariableSetterDeclaration): simpleTransformationResult.Type<ir.TypeVariableSetterDeclaration>;
+    transformVariantDeclaration?(declaration: ir.VariantDeclaration): simpleTransformationResult.Type<ir.VariantDeclaration>;
+    transformCallArguments?(declaration: ir.CallArguments): simpleTransformationResult.Type<ir.CallArguments>;
+    transformOnErrorClause?(clause: ir.OnErrorClause): simpleTransformationResult.Type<ir.OnErrorClause>;
+    transformFinallyClause?(clause: ir.FinallyClause): simpleTransformationResult.Type<ir.FinallyClause>;
+    transformJsObjectLiteralProperty?(clause: ir.JsObjectLiteralProperty): simpleTransformationResult.Type<ir.JsObjectLiteralProperty>;
+}
+export type TransformingContainer = TransformingContainer_typeMethod | TransformingContainer_typeConstructor | TransformingContainer_typeIndexedGetter | TransformingContainer_typeIndexedSetter | TransformingContainer_typeDereferencedVariableGetter | TransformingContainer_typeDereferencedVariableSetter | TransformingContainer_typeVariableGetter | TransformingContainer_typeVariableSetter;
+export declare class TransformingContainer_typeMethod {
+    readonly declaration: ir.TypeMethodDeclaration;
+    readonly kind = "type-method";
+    constructor(declaration: ir.TypeMethodDeclaration);
+}
+export declare class TransformingContainer_typeConstructor {
+    readonly declaration: ir.TypeConstructorDeclaration;
+    readonly kind = "type-constructor";
+    constructor(declaration: ir.TypeConstructorDeclaration);
+}
+export declare class TransformingContainer_typeIndexedGetter {
+    readonly declaration: ir.TypeIndexedGetterDeclaration;
+    readonly indexer: IndexerEntity;
+    readonly kind = "type-indexed-getter";
+    constructor(declaration: ir.TypeIndexedGetterDeclaration, indexer: IndexerEntity);
+}
+export declare class TransformingContainer_typeIndexedSetter {
+    readonly declaration: ir.TypeIndexedSetterDeclaration;
+    readonly indexer: IndexerEntity;
+    readonly kind = "type-indexed-setter";
+    constructor(declaration: ir.TypeIndexedSetterDeclaration, indexer: IndexerEntity);
+}
+export declare class TransformingContainer_typeDereferencedVariableGetter {
+    readonly declaration: ir.TypeDereferencedVariableGetterDeclaration;
+    readonly operator: DereferenceOperatorEntity;
+    readonly kind = "type-dereferenced-variable-getter";
+    constructor(declaration: ir.TypeDereferencedVariableGetterDeclaration, operator: DereferenceOperatorEntity);
+}
+export declare class TransformingContainer_typeDereferencedVariableSetter {
+    readonly declaration: ir.TypeDereferencedVariableSetterDeclaration;
+    readonly operator: DereferenceOperatorEntity;
+    readonly kind = "type-dereferenced-variable-setter";
+    constructor(declaration: ir.TypeDereferencedVariableSetterDeclaration, operator: DereferenceOperatorEntity);
+}
+export declare class TransformingContainer_typeVariableGetter {
+    readonly declaration: ir.TypeVariableGetterDeclaration;
+    readonly variable: VariableEntity;
+    readonly kind = "type-variable-getter";
+    constructor(declaration: ir.TypeVariableGetterDeclaration, variable: VariableEntity);
+}
+export declare class TransformingContainer_typeVariableSetter {
+    readonly declaration: ir.TypeVariableSetterDeclaration;
+    readonly variable: VariableEntity;
+    readonly kind = "type-variable-setter";
+    constructor(declaration: ir.TypeVariableSetterDeclaration, variable: VariableEntity);
+}
+export {};

package/build/types/emitter/TypeAccessExpressionTransformationResult.d.ts

@@ -0,0 +1,12 @@
+import { expressionTransformationResult } from './Internal.js';
+import { TransformationContinuationAction } from './TransformationContinuationAction.js';
+import { TypeAccessExpression } from './ir/index.js';
+export type TypeAccessExpressionTransformationResult = {
+    kind: expressionTransformationResult.Kind.Preserve;
+    action: TransformationContinuationAction;
+} | {
+    kind: expressionTransformationResult.Kind.Replace;
+    expression: TypeAccessExpression;
+};
+export declare function preserve(action?: TransformationContinuationAction): TypeAccessExpressionTransformationResult;
+export declare function replace(expression: TypeAccessExpression): TypeAccessExpressionTransformationResult;

package/build/types/emitter/error-boundary.d.ts

@@ -0,0 +1,10 @@
+import { DebugStack } from './DebugStack.js';
+import { Node } from './ir/index.js';
+export declare function errorBoundary<T>(fn: () => T): T | undefined;
+export declare class EmitterError extends Error {
+    message: string;
+    node?: Node | undefined;
+    debugStack?: DebugStack | undefined;
+    originalError?: Error | undefined;
+    constructor(message: string, node?: Node | undefined, debugStack?: DebugStack | undefined, originalError?: Error | undefined);
+}

package/build/types/emitter/index.d.ts

@@ -0,0 +1 @@
+export * from './Emitter.js';

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

@@ -0,0 +1,19 @@
+import { IndexerEntity, MethodEntity, VariableEntity } from '../../entities/index.js';
+import * as types from '../../types/index.js';
+export declare class AccessedVariable {
+    readonly entity: VariableEntity;
+    readonly type: types.Type;
+    constructor(entity: VariableEntity, type: types.Type);
+    static fromEntity(entity: VariableEntity): AccessedVariable;
+}
+export declare class AccessedMethod {
+    readonly entity: MethodEntity;
+    readonly returnType: types.Type;
+    constructor(entity: MethodEntity, returnType: types.Type);
+    static fromEntity(entity: MethodEntity): AccessedMethod;
+}
+export declare class AccessedIndexer {
+    readonly entity: IndexerEntity;
+    readonly type: types.Type;
+    constructor(entity: IndexerEntity, type: types.Type);
+}

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

@@ -0,0 +1,34 @@
+export declare class AssignmentLoweringOptions {
+    readonly incrementReferenceCountIfRequired: boolean;
+    readonly performCopyIfRequired: boolean;
+    readonly decrementReferenceCountIfRequired: boolean;
+    constructor(incrementReferenceCountIfRequired: boolean, performCopyIfRequired: boolean, decrementReferenceCountIfRequired: boolean);
+    setIncrementReferenceCountIfRequired(value: boolean): AssignmentLoweringOptions;
+    setPerformCopyIfRequired(value: boolean): AssignmentLoweringOptions;
+    setDecrementReferenceCountIfRequired(value: boolean): AssignmentLoweringOptions;
+}
+export declare class DeclarationWithInitializerLoweringOptions {
+    readonly incrementReferenceCountIfRequired: boolean;
+    constructor(incrementReferenceCountIfRequired: boolean);
+    setIncrementReferenceCountIfRequired(value: boolean): DeclarationWithInitializerLoweringOptions;
+}
+export declare class CallExpressionLoweringOptions {
+    readonly lowerModifyingMethodCallIfRequired: boolean;
+    constructor(lowerModifyingMethodCallIfRequired: boolean);
+    setLowerModifyingMethodCallIfRequired(value: boolean): CallExpressionLoweringOptions;
+}
+export declare class ConstructorCallExpressionLoweringOptions {
+    readonly lowerPlainObjectConstructionIfRequired: boolean;
+    constructor(lowerPlainObjectConstructionIfRequired: boolean);
+    setLowerPlainObjectConstructionIfRequired(value: boolean): ConstructorCallExpressionLoweringOptions;
+}
+export declare class MethodAccessLoweringOptions {
+    readonly bindIfNotCallee: boolean;
+    constructor(bindIfNotCallee: boolean);
+    setBindIfNotCallee(value: boolean): MethodAccessLoweringOptions;
+}
+export declare class TextTemplateLiteralLoweringOptions {
+    readonly createTextTemplateInstance: boolean;
+    constructor(createTextTemplateInstance: boolean);
+    setCreateTextTemplateInstance(value: boolean): TextTemplateLiteralLoweringOptions;
+}