@algorandfoundation/puya-ts 1.0.0-alpha.4

package/awst/source-location.d.ts

@@ -0,0 +1,21 @@
+import type ts from 'typescript';
+export declare class SourceLocation {
+    file: string;
+    line: number;
+    endLine: number;
+    column: number;
+    endColumn: number;
+    constructor(props: {
+        file: string;
+        line: number;
+        endLine: number;
+        column: number;
+        endColumn: number;
+    });
+    static fromNode(sourceFile: ts.SourceFile, node: ts.Node, programDirectory: string): SourceLocation;
+    static fromFile(sourceFile: ts.SourceFile, programDirectory: string): SourceLocation;
+    static fromTextRange(sourceFile: ts.SourceFile, textRange: ts.TextRange, programDirectory: string): SourceLocation;
+    static fromDiagnostic(diagnostic: ts.DiagnosticWithLocation, programDirectory: string): SourceLocation;
+    toString(): string;
+    static fromLocations(...sourceLocation: SourceLocation[]): SourceLocation;
+}

package/awst/to-code-visitor.d.ts

@@ -0,0 +1,87 @@
+import type { AppStorageDefinition, ContractMemberNodeVisitor, ExpressionVisitor, RootNodeVisitor, StatementVisitor } from './nodes';
+import * as nodes from './nodes';
+export declare class ToCodeVisitor implements RootNodeVisitor<string[]>, ContractMemberNodeVisitor<string[]>, StatementVisitor<string[]>, ExpressionVisitor<string> {
+    #private;
+    visitRange(expression: nodes.Range): string;
+    visitVoidConstant(expression: nodes.VoidConstant): string;
+    visitGroupTransactionReference(expression: nodes.GroupTransactionReference): string;
+    visitPuyaLibCall(expression: nodes.PuyaLibCall): string;
+    visitARC4Router(expression: nodes.ARC4Router): string;
+    visitAppStorageDefinition(contractMemberNode: AppStorageDefinition): string[];
+    visitUInt64PostfixUnaryOperation(expression: nodes.UInt64PostfixUnaryOperation): string;
+    visitBigUIntPostfixUnaryOperation(expression: nodes.BigUIntPostfixUnaryOperation): string;
+    visitCompiledContract(expression: nodes.CompiledContract): string;
+    visitCompiledLogicSig(expression: nodes.CompiledLogicSig): string;
+    visitLoopExit(statement: nodes.LoopExit): string[];
+    visitLoopContinue(statement: nodes.LoopContinue): string[];
+    visitGoto(statement: nodes.Goto): string[];
+    visitIntersectionSliceExpression(expression: nodes.IntersectionSliceExpression): string;
+    visitBoxValueExpression(expression: nodes.BoxValueExpression): string;
+    visitIntegerConstant(expression: nodes.IntegerConstant): string;
+    visitDecimalConstant(expression: nodes.DecimalConstant): string;
+    visitBoolConstant(expression: nodes.BoolConstant): string;
+    visitBytesConstant(expression: nodes.BytesConstant): string;
+    visitStringConstant(expression: nodes.StringConstant): string;
+    visitTemplateVar(expression: nodes.TemplateVar): string;
+    visitMethodConstant(expression: nodes.MethodConstant): string;
+    visitAddressConstant(expression: nodes.AddressConstant): string;
+    visitARC4Encode(expression: nodes.ARC4Encode): string;
+    visitCopy(expression: nodes.Copy): string;
+    visitArrayConcat(expression: nodes.ArrayConcat): string;
+    visitArrayPop(expression: nodes.ArrayPop): string;
+    visitArrayExtend(expression: nodes.ArrayExtend): string;
+    visitARC4Decode(expression: nodes.ARC4Decode): string;
+    visitIntrinsicCall(expression: nodes.IntrinsicCall): string;
+    visitCreateInnerTransaction(expression: nodes.CreateInnerTransaction): string;
+    visitUpdateInnerTransaction(expression: nodes.UpdateInnerTransaction): string;
+    visitCheckedMaybe(expression: nodes.CheckedMaybe): string;
+    visitTupleExpression(expression: nodes.TupleExpression): string;
+    visitTupleItemExpression(expression: nodes.TupleItemExpression): string;
+    visitVarExpression(expression: nodes.VarExpression): string;
+    visitInnerTransactionField(expression: nodes.InnerTransactionField): string;
+    visitSubmitInnerTransaction(expression: nodes.SubmitInnerTransaction): string;
+    visitFieldExpression(expression: nodes.FieldExpression): string;
+    visitIndexExpression(expression: nodes.IndexExpression): string;
+    visitSliceExpression(expression: nodes.SliceExpression): string;
+    visitAppStateExpression(expression: nodes.AppStateExpression): string;
+    visitAppAccountStateExpression(expression: nodes.AppAccountStateExpression): string;
+    visitSingleEvaluation(expression: nodes.SingleEvaluation): string;
+    visitReinterpretCast(expression: nodes.ReinterpretCast): string;
+    visitNewArray(expression: nodes.NewArray): string;
+    visitConditionalExpression(expression: nodes.ConditionalExpression): string;
+    visitAssignmentExpression(expression: nodes.AssignmentExpression): string;
+    visitNumericComparisonExpression(expression: nodes.NumericComparisonExpression): string;
+    visitBytesComparisonExpression(expression: nodes.BytesComparisonExpression): string;
+    visitSubroutineCallExpression(expression: nodes.SubroutineCallExpression): string;
+    visitCallTarget(target: nodes.SubroutineCallExpression['target']): string;
+    visitUInt64UnaryOperation(expression: nodes.UInt64UnaryOperation): string;
+    visitBytesUnaryOperation(expression: nodes.BytesUnaryOperation): string;
+    visitUInt64BinaryOperation(expression: nodes.UInt64BinaryOperation): string;
+    visitBigUIntBinaryOperation(expression: nodes.BigUIntBinaryOperation): string;
+    visitBytesBinaryOperation(expression: nodes.BytesBinaryOperation): string;
+    visitBooleanBinaryOperation(expression: nodes.BooleanBinaryOperation): string;
+    visitNot(expression: nodes.Not): string;
+    visitEnumeration(expression: nodes.Enumeration): string;
+    visitReversed(expression: nodes.Reversed): string;
+    visitStateGet(expression: nodes.StateGet): string;
+    visitStateDelete(expression: nodes.StateDelete): string;
+    visitStateGetEx(expression: nodes.StateGetEx): string;
+    visitStateExists(expression: nodes.StateExists): string;
+    visitNewStruct(expression: nodes.NewStruct): string;
+    visitExpressionStatement(statement: nodes.ExpressionStatement): string[];
+    visitBlock(statement: nodes.Block): string[];
+    visitIfElse(statement: nodes.IfElse): string[];
+    visitSwitch(statement: nodes.Switch): string[];
+    visitWhileLoop(statement: nodes.WhileLoop): string[];
+    visitReturnStatement(statement: nodes.ReturnStatement): string[];
+    visitAssignmentStatement(statement: nodes.AssignmentStatement): string[];
+    visitUInt64AugmentedAssignment(statement: nodes.UInt64AugmentedAssignment): string[];
+    visitBigUIntAugmentedAssignment(statement: nodes.BigUIntAugmentedAssignment): string[];
+    visitBytesAugmentedAssignment(statement: nodes.BytesAugmentedAssignment): string[];
+    visitForInLoop(statement: nodes.ForInLoop): string[];
+    visitSubroutine(moduleStatement: nodes.Subroutine): string[];
+    visitContractMethod(statement: nodes.ContractMethod): string[];
+    visitLogicSignature(moduleStatement: nodes.LogicSignature): string[];
+    visitContractFragment(c: nodes.ContractFragment): string[];
+    visitSpecialMethod(statement: nodes.ContractMethod, name: string): string[];
+}

package/awst/txn-fields.d.ts

@@ -0,0 +1,84 @@
+import { wtypes } from './index';
+export declare class TxnFieldData {
+    readonly immediate: string;
+    readonly wtype: wtypes.WType;
+    readonly numValues: number;
+    readonly isInnerParam: boolean;
+    constructor(data: {
+        field: TxnField;
+        wtype: wtypes.WType;
+        numValues?: number;
+        isInnerParam?: boolean;
+    });
+}
+export declare enum TxnField {
+    Sender = "Sender",
+    Fee = "Fee",
+    FirstValid = "FirstValid",
+    FirstValidTime = "FirstValidTime",
+    LastValid = "LastValid",
+    Note = "Note",
+    Lease = "Lease",
+    Receiver = "Receiver",
+    Amount = "Amount",
+    CloseRemainderTo = "CloseRemainderTo",
+    VotePK = "VotePK",
+    SelectionPK = "SelectionPK",
+    VoteFirst = "VoteFirst",
+    VoteLast = "VoteLast",
+    VoteKeyDilution = "VoteKeyDilution",
+    Type = "Type",
+    TypeEnum = "TypeEnum",
+    XferAsset = "XferAsset",
+    AssetAmount = "AssetAmount",
+    AssetSender = "AssetSender",
+    AssetReceiver = "AssetReceiver",
+    AssetCloseTo = "AssetCloseTo",
+    GroupIndex = "GroupIndex",
+    TxID = "TxID",
+    ApplicationID = "ApplicationID",
+    OnCompletion = "OnCompletion",
+    NumAppArgs = "NumAppArgs",
+    NumAccounts = "NumAccounts",
+    ApprovalProgram = "ApprovalProgram",
+    ClearStateProgram = "ClearStateProgram",
+    RekeyTo = "RekeyTo",
+    ConfigAsset = "ConfigAsset",
+    ConfigAssetTotal = "ConfigAssetTotal",
+    ConfigAssetDecimals = "ConfigAssetDecimals",
+    ConfigAssetDefaultFrozen = "ConfigAssetDefaultFrozen",
+    ConfigAssetUnitName = "ConfigAssetUnitName",
+    ConfigAssetName = "ConfigAssetName",
+    ConfigAssetURL = "ConfigAssetURL",
+    ConfigAssetMetadataHash = "ConfigAssetMetadataHash",
+    ConfigAssetManager = "ConfigAssetManager",
+    ConfigAssetReserve = "ConfigAssetReserve",
+    ConfigAssetFreeze = "ConfigAssetFreeze",
+    ConfigAssetClawback = "ConfigAssetClawback",
+    FreezeAsset = "FreezeAsset",
+    FreezeAssetAccount = "FreezeAssetAccount",
+    FreezeAssetFrozen = "FreezeAssetFrozen",
+    NumAssets = "NumAssets",
+    NumApplications = "NumApplications",
+    GlobalNumUint = "GlobalNumUint",
+    GlobalNumByteSlice = "GlobalNumByteSlice",
+    LocalNumUint = "LocalNumUint",
+    LocalNumByteSlice = "LocalNumByteSlice",
+    ExtraProgramPages = "ExtraProgramPages",
+    Nonparticipation = "Nonparticipation",
+    NumLogs = "NumLogs",
+    CreatedAssetID = "CreatedAssetID",
+    CreatedApplicationID = "CreatedApplicationID",
+    LastLog = "LastLog",
+    StateProofPK = "StateProofPK",
+    NumApprovalProgramPages = "NumApprovalProgramPages",
+    NumClearStateProgramPages = "NumClearStateProgramPages",
+    ApplicationArgs = "ApplicationArgs",
+    Accounts = "Accounts",
+    Assets = "Assets",
+    Applications = "Applications",
+    Logs = "Logs",
+    ApprovalProgramPages = "ApprovalProgramPages",
+    ClearStateProgramPages = "ClearStateProgramPages"
+}
+export declare const TxnFields: Record<TxnField, TxnFieldData>;

package/awst/util.d.ts

@@ -0,0 +1,2 @@
+import type { Constant, Expression } from './nodes';
+export declare function isConstant(expr: Expression): expr is Constant;

package/awst/wtypes.d.ts

@@ -0,0 +1,131 @@
+import { TransactionKind } from './models';
+import type { SourceLocation } from './source-location';
+export declare enum AVMType {
+    bytes = 1,
+    uint64 = 2,
+    any = 3
+}
+export declare class WType {
+    constructor(props: {
+        name: string;
+        immutable?: boolean;
+        scalarType: AVMType | null;
+        ephemeral?: boolean;
+    });
+    readonly name: string;
+    readonly immutable: boolean;
+    /**
+     * ephemeral types are not suitable for naive storage / persistence,
+     *      even if their underlying type is a simple stack value
+     */
+    readonly ephemeral: boolean;
+    /**
+     * The AVM stack type of this type (if any)
+     */
+    readonly scalarType: AVMType | null;
+    equals(other: WType): boolean;
+    toString(): string;
+    get id(): string;
+}
+export declare const voidWType: WType;
+export declare const boolWType: WType;
+export declare const uint64WType: WType;
+export declare const uint64RangeWType: WType;
+export declare const bytesWType: WType;
+export declare const stateKeyWType: WType;
+export declare const boxKeyWType: WType;
+export declare const stringWType: WType;
+export declare const biguintWType: WType;
+export declare const assetWType: WType;
+export declare const accountWType: WType;
+export declare const applicationWType: WType;
+export declare abstract class ARC4Type extends WType {
+    readonly decodeType: WType | null;
+    readonly arc4Name: string;
+    readonly otherEncodeableTypes: WType[];
+    constructor({ decodeType, arc4Name, otherEncodeableTypes, ...rest }: {
+        decodeType: WType | null;
+        arc4Name: string;
+        otherEncodeableTypes: WType[];
+        name: string;
+        immutable?: boolean;
+        scalarType: AVMType | null;
+        ephemeral?: boolean;
+    });
+}
+export declare class WStructType extends WType {
+}
+export declare class WTuple extends WType {
+    types: WType[];
+    constructor(props: {
+        types: WType[];
+        immutable?: boolean;
+    });
+    toString(): string;
+}
+export declare class WArray extends WType {
+    readonly itemType: WType;
+    constructor(props: {
+        itemType: WType;
+        immutable: boolean;
+    });
+}
+export declare class WEnumeration extends WType {
+    readonly sequenceType: WType;
+    constructor(props: {
+        sequenceType: WType;
+    });
+}
+export declare class WGroupTransaction extends WType {
+    transactionType: TransactionKind | null;
+    constructor({ transactionType }: {
+        transactionType?: TransactionKind;
+    });
+}
+export declare class WInnerTransaction extends WType {
+    transactionType: TransactionKind | null;
+    constructor({ transactionType }: {
+        transactionType?: TransactionKind;
+    });
+}
+export declare class WInnerTransactionFields extends WType {
+    transactionType: TransactionKind | null;
+    constructor({ transactionType }: {
+        transactionType?: TransactionKind;
+    });
+}
+export declare class ARC4UIntN extends ARC4Type {
+    readonly n: bigint;
+    constructor({ n }: {
+        n: bigint;
+    });
+}
+export declare class ARC4UFixedNxM extends ARC4Type {
+}
+export declare class ARC4Struct extends ARC4Type {
+}
+export declare abstract class ARC4Array extends ARC4Type {
+    readonly elementType: ARC4Type;
+    protected constructor(props: {
+        arc4Name: string;
+        otherEncodeableTypes: WType[];
+        name: string;
+        elementType: ARC4Type;
+    });
+}
+export declare class ARC4DynamicArray extends ARC4Array {
+    readonly sourceLocation: SourceLocation | null;
+    constructor({ elementType, sourceLocation }: {
+        elementType: ARC4Type;
+        sourceLocation?: SourceLocation;
+    });
+}
+export declare class ARC4StaticArray extends ARC4Array {
+    readonly sourceLocation: SourceLocation | null;
+    readonly arraySize: bigint;
+    constructor({ elementType, sourceLocation, arraySize }: {
+        arraySize: bigint;
+        elementType: ARC4Type;
+        sourceLocation?: SourceLocation;
+    });
+}

package/awst_build/base-visitor.d.ts

@@ -0,0 +1,87 @@
+import ts from 'typescript';
+import type { Expression, LValue, Statement } from '../awst/nodes';
+import type { SourceLocation } from '../awst/source-location';
+import type { Expressions } from '../visitor/syntax-names';
+import type { Visitor } from '../visitor/visitor';
+import type { AwstBuildContext } from './context/awst-build-context';
+import type { InstanceBuilder } from './eb';
+import { NodeBuilder } from './eb';
+import type { PType } from './ptypes';
+import { TextVisitor } from './text-visitor';
+export declare abstract class BaseVisitor implements Visitor<Expressions, NodeBuilder> {
+    context: AwstBuildContext;
+    private baseAccept;
+    readonly textVisitor: TextVisitor;
+    protected constructor(context: AwstBuildContext);
+    logNotSupported(node: ts.Node | undefined, message: string): void;
+    throwNotSupported(node: ts.Node, message: string): never;
+    visitBigIntLiteral(node: ts.BigIntLiteral): InstanceBuilder;
+    visitRegularExpressionLiteral(node: ts.RegularExpressionLiteral): InstanceBuilder;
+    visitFalseKeyword(node: ts.FalseLiteral): InstanceBuilder;
+    visitTrueKeyword(node: ts.TrueLiteral): InstanceBuilder;
+    sourceLocation(node: ts.Node): SourceLocation;
+    visitStringLiteral(node: ts.StringLiteral): InstanceBuilder;
+    visitNoSubstitutionTemplateLiteral(node: ts.NoSubstitutionTemplateLiteral): InstanceBuilder;
+    visitNumericLiteral(node: ts.NumericLiteral): InstanceBuilder;
+    visitIdentifier(node: ts.Identifier): NodeBuilder;
+    visitImportKeyword(node: ts.ImportExpression): NodeBuilder;
+    visitNullKeyword(node: ts.NullLiteral): NodeBuilder;
+    visitPrivateIdentifier(node: ts.PrivateIdentifier): NodeBuilder;
+    visitSuperKeyword(node: ts.SuperExpression): NodeBuilder;
+    visitThisKeyword(node: ts.ThisExpression): NodeBuilder;
+    visitFunctionExpression(node: ts.FunctionExpression): NodeBuilder;
+    visitClassExpression(node: ts.ClassExpression): NodeBuilder;
+    visitObjectLiteralExpression(node: ts.ObjectLiteralExpression): NodeBuilder;
+    visitArrayLiteralExpression(node: ts.ArrayLiteralExpression): NodeBuilder;
+    visitPropertyAccessExpression(node: ts.PropertyAccessExpression): NodeBuilder;
+    visitElementAccessExpression(node: ts.ElementAccessExpression): NodeBuilder;
+    visitCallExpression(node: ts.CallExpression): NodeBuilder;
+    visitNewExpression(node: ts.NewExpression): NodeBuilder;
+    visitTaggedTemplateExpression(node: ts.TaggedTemplateExpression): NodeBuilder;
+    visitTypeAssertionExpression(node: ts.TypeAssertion): NodeBuilder;
+    visitParenthesizedExpression(node: ts.ParenthesizedExpression): NodeBuilder;
+    /**
+     * `delete obj.prop`
+     *
+     * Not supported currently as typescript requires 'prop' to be optional and we don't support optional values
+     */
+    visitDeleteExpression(node: ts.DeleteExpression): NodeBuilder;
+    visitTypeOfExpression(node: ts.TypeOfExpression): NodeBuilder;
+    visitVoidExpression(node: ts.VoidExpression): NodeBuilder;
+    visitAwaitExpression(node: ts.AwaitExpression): NodeBuilder;
+    visitPrefixUnaryExpression(node: ts.PrefixUnaryExpression): NodeBuilder;
+    visitPostfixUnaryExpression(node: ts.PostfixUnaryExpression): NodeBuilder;
+    evaluateCondition(nodeOrBuilder: ts.Expression | NodeBuilder, negate?: boolean): Expression;
+    visitBinaryExpression(node: ts.BinaryExpression): NodeBuilder;
+    visitConditionalExpression(node: ts.ConditionalExpression): NodeBuilder;
+    createConditionalExpression({ condition, ptype, whenFalse, whenTrue, sourceLocation, }: {
+        ptype: PType;
+        condition: Expression;
+        whenTrue: InstanceBuilder;
+        whenFalse: InstanceBuilder;
+        sourceLocation: SourceLocation;
+    }): InstanceBuilder;
+    visitTemplateExpression(node: ts.TemplateExpression): NodeBuilder;
+    visitYieldExpression(node: ts.YieldExpression): NodeBuilder;
+    visitOmittedExpression(node: ts.OmittedExpression): NodeBuilder;
+    visitExpressionWithTypeArguments(node: ts.ExpressionWithTypeArguments): NodeBuilder;
+    visitAsExpression(node: ts.AsExpression): NodeBuilder;
+    visitNonNullExpression(node: ts.NonNullExpression): NodeBuilder;
+    visitSatisfiesExpression(node: ts.SatisfiesExpression): NodeBuilder;
+    handleAssignmentStatement(target: InstanceBuilder, source: InstanceBuilder, sourceLocation: SourceLocation): Statement;
+    handleAssignment(target: InstanceBuilder, source: InstanceBuilder, sourceLocation: SourceLocation): InstanceBuilder;
+    /**
+     * Given a target and source type, produce a type that represents the result of an assignment expression.
+     *
+     * This will largely represent the sourceType verbatim with the exception of numeric literal types which need
+     * to be narrowed using the targetType.
+     *
+     * Eg. a `number` on the rhs should be narrowed to whatever the lhs is for example uint64.
+     * @param targetType The type of the assignment target
+     * @param sourceType The type of the assignment source
+     * @param sourceLocation
+     * @private
+     */
+    private buildAssignmentExpressionType;
+    buildLValue(target: InstanceBuilder, assignmentType: PType, sourceLocation: SourceLocation): LValue;
+}

package/awst_build/constructor-visitor.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import type { ContractReference } from '../awst/models';
+import * as awst from '../awst/nodes';
+import type { AwstBuildContext } from './context/awst-build-context';
+import { ContractMethodBaseVisitor } from './contract-method-visitor';
+export interface ConstructorInfo {
+    propertyInitializerStatements: awst.Statement[];
+    cref: ContractReference;
+}
+export declare class ConstructorVisitor extends ContractMethodBaseVisitor {
+    private readonly _result;
+    private _foundSuperCall;
+    private readonly _propertyInitializerStatements;
+    constructor(ctx: AwstBuildContext, node: ts.ConstructorDeclaration, contractInfo: ConstructorInfo);
+    get result(): awst.ContractMethod;
+    static buildConstructor(parentCtx: AwstBuildContext, node: ts.ConstructorDeclaration, constructorMethodInfo: ConstructorInfo): awst.ContractMethod;
+    visitBlock(node: ts.Block): awst.Block;
+}

package/awst_build/context/awst-build-context.d.ts

@@ -0,0 +1,72 @@
+import ts from 'typescript';
+import type { awst } from '../../awst';
+import type { CompilationSet, ContractReference, LogicSigReference } from '../../awst/models';
+import type { AppStorageDefinition } from '../../awst/nodes';
+import { SourceLocation } from '../../awst/source-location';
+import type { AppStorageDeclaration } from '../contract-data';
+import type { NodeBuilder } from '../eb';
+import type { ContractClassPType, PType } from '../ptypes';
+import { EvaluationContext } from './evaluation-context';
+import { SwitchLoopContext } from './switch-loop-context';
+export interface AwstBuildContext {
+    /**
+     * Get the source location of a node in the current source file
+     * @param node
+     */
+    getSourceLocation(node: ts.Node): SourceLocation;
+    /**
+     * Get NodeBuilder instance for the given identifier.
+     * @param node
+     */
+    getBuilderForNode(node: ts.Identifier): NodeBuilder;
+    /**
+     * Reflect the PType of the given node
+     * @param node
+     */
+    getPTypeForNode(node: ts.Node): PType;
+    /**
+     * Reflect generic type parameters for a call expression
+     * @param node
+     */
+    getTypeParameters(node: ts.CallExpression): PType[];
+    /**
+     * Resolve the given identifier to a unique variable name that accounts
+     * for shadowed variable names.
+     * @param node
+     */
+    resolveVariableName(node: ts.Identifier): string;
+    /**
+     * Resolve the given parameter declaration to a unique parameter name to be used
+     * in destructuring assignments where no explicit parameter name is available.
+     * @param node
+     */
+    resolveDestructuredParamName(node: ts.ParameterDeclaration): string;
+    /**
+     * Generate a unique variable name for a discarded value.
+     */
+    generateDiscardedVarName(): string;
+    /**
+     * Add a named constant to the current context
+     * @param name The unique name of the constant declaration in this source file
+     * @param value The compile time constant value
+     */
+    addConstant(name: string, value: awst.Constant): void;
+    /**
+     * Retrieve the evaluation context
+     */
+    get evaluationCtx(): EvaluationContext;
+    /**
+     * Retrieve the switch loop context
+     */
+    get switchLoopCtx(): SwitchLoopContext;
+    /**
+     * Create a child context from this context. Used when entering a child parsing context such as a class or function.
+     */
+    createChildContext(): AwstBuildContext;
+    addStorageDeclaration(declaration: AppStorageDeclaration): void;
+    getStorageDeclaration(contractType: ContractClassPType, memberName: string): AppStorageDeclaration | undefined;
+    getStorageDefinitionsForContract(contractType: ContractClassPType): Map<string, AppStorageDefinition>;
+    addToCompilationSet(compilationTarget: ContractReference | LogicSigReference): void;
+    get compilationSet(): CompilationSet;
+}
+export declare function buildContextForProgram(program: ts.Program): AwstBuildContext;

package/awst_build/context/evaluation-context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tracks the context in which expressions should be evaluated.
+ *
+ * A boolean context is more lenient with mixed expression types as it is only concerned with truthy-ness
+ */
+export declare class EvaluationContext {
+    #private;
+    get isBoolean(): boolean;
+    enterBooleanContext(): Disposable;
+    leaveBooleanContext(): Disposable;
+}

package/awst_build/context/switch-loop-context.d.ts

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import type { Block, Goto } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+type LoopContext = Disposable & {
+    breakTarget: Block;
+    continueTarget: Block;
+    readonly hasBreaks: boolean;
+    readonly hasContinues: boolean;
+};
+type SwitchContext = Disposable & {
+    breakTarget: Block;
+    caseTarget(caseIndex: number, sourceLocation: SourceLocation): Block;
+    gotoCase(caseIndex: number, sourceLocation: SourceLocation): Goto;
+    readonly hasBreaks: boolean;
+};
+/**
+ * Tracks parent switches and loops so that break and continue statements
+ * can target the correct parent.
+ */
+export declare class SwitchLoopContext {
+    private labelCount;
+    private unlabelledCount;
+    constructor();
+    private switchLoopStack;
+    getBreakTarget(label: ts.Identifier | undefined, sourceLocation: SourceLocation): string;
+    getContinueTarget(label: ts.Identifier | undefined, sourceLocation: SourceLocation): string;
+    enterLoop(node: ts.WhileStatement | ts.ForStatement | ts.ForOfStatement | ts.ForInStatement | ts.DoStatement, sourceLocation: SourceLocation): LoopContext;
+    private uniqueNameForLabel;
+    enterSwitch(node: ts.SwitchStatement, sourceLocation: SourceLocation): SwitchContext;
+}
+export {};

package/awst_build/context/unique-name-resolver.d.ts

@@ -0,0 +1,14 @@
+import type ts from 'typescript';
+export declare class UniqueNameResolver {
+    protected readonly symbolToName: Map<ts.Symbol, string>;
+    protected readonly nameToCount: Map<string, number>;
+    constructor(parent?: UniqueNameResolver);
+    /**
+     * Resolve a rawName to a unique name within the scope of this resolver. When provided
+     * with a symbol which has already been seen, return the same name
+     * @param rawName
+     * @param symbol
+     */
+    resolveUniqueName(rawName: string, symbol: ts.Symbol | undefined): string;
+    createChild(): UniqueNameResolver;
+}

package/awst_build/contract-data.d.ts

@@ -0,0 +1,24 @@
+import type { AppStorageDefinition, BytesConstant } from '../awst/nodes';
+import { AppStorageKind } from '../awst/nodes';
+import type { SourceLocation } from '../awst/source-location';
+import type { ContractClassPType, StorageProxyPType } from './ptypes';
+import { BoxMapPType, BoxPType, BoxRefPType, GlobalStateType, LocalStateType } from './ptypes';
+export declare class AppStorageDeclaration {
+    readonly memberName: string;
+    readonly ptype: GlobalStateType | LocalStateType | BoxMapPType | BoxPType | BoxRefPType;
+    readonly keyOverride: BytesConstant | null;
+    readonly sourceLocation: SourceLocation;
+    readonly definedIn: ContractClassPType;
+    readonly description: string | null;
+    constructor(props: {
+        memberName: string;
+        ptype: StorageProxyPType;
+        keyOverride: BytesConstant | null;
+        sourceLocation: SourceLocation;
+        definedIn: ContractClassPType;
+        description: string | null;
+    });
+    get kind(): AppStorageKind;
+    get key(): BytesConstant;
+    get definition(): AppStorageDefinition;
+}

package/awst_build/contract-method-visitor.d.ts

@@ -0,0 +1,20 @@
+import type ts from 'typescript';
+import type { ContractReference } from '../awst/models';
+import * as awst from '../awst/nodes';
+import type { AwstBuildContext } from './context/awst-build-context';
+import type { NodeBuilder } from './eb';
+import { FunctionVisitor } from './function-visitor';
+export type ContractMethodInfo = {
+    cref: ContractReference;
+    arc4MethodConfig?: awst.ContractMethod['arc4MethodConfig'];
+};
+export declare class ContractMethodBaseVisitor extends FunctionVisitor {
+    visitSuperKeyword(node: ts.SuperExpression): NodeBuilder;
+    visitThisKeyword(node: ts.ThisExpression): NodeBuilder;
+}
+export declare class ContractMethodVisitor extends ContractMethodBaseVisitor {
+    private readonly _result;
+    constructor(ctx: AwstBuildContext, node: ts.MethodDeclaration, contractInfo: ContractMethodInfo);
+    get result(): awst.ContractMethod;
+    static buildContractMethod(parentCtx: AwstBuildContext, node: ts.MethodDeclaration, contractMethodInfo: ContractMethodInfo): awst.ContractMethod;
+}

package/awst_build/contract-visitor.d.ts

@@ -0,0 +1,33 @@
+import ts from 'typescript';
+import type * as awst from '../awst/nodes';
+import { ContractFragment } from '../awst/nodes';
+import type { ClassElements } from '../visitor/syntax-names';
+import type { Visitor } from '../visitor/visitor';
+import { BaseVisitor } from './base-visitor';
+import type { AwstBuildContext } from './context/awst-build-context';
+export declare class ContractVisitor extends BaseVisitor implements Visitor<ClassElements, void> {
+    private _ctor?;
+    private _subroutines;
+    private _approvalProgram;
+    private _clearStateProgram;
+    private _className;
+    private _contractPType;
+    private readonly _propertyInitialization;
+    readonly result: ContractFragment;
+    accept: <TNode extends ts.Node>(node: TNode) => import("../visitor/visitor").MethodReturnType<import("../visitor/visitor").VisitorMethod<import("../visitor/visitor").KindForNode<import("../visitor/syntax-names").MapBaseType<TNode>>>, ContractVisitor>;
+    constructor(ctx: AwstBuildContext, classDec: ts.ClassDeclaration);
+    private acceptAndIgnoreBuildErrors;
+    private makeDefaultConstructor;
+    private getBaseContracts;
+    visitClassStaticBlockDeclaration(node: ts.ClassStaticBlockDeclaration): void;
+    visitConstructor(node: ts.ConstructorDeclaration): void;
+    visitGetAccessor(node: ts.GetAccessorDeclaration): void;
+    visitIndexSignature(node: ts.IndexSignatureDeclaration): void;
+    private buildDefaultArgument;
+    private buildArc4Config;
+    visitMethodDeclaration(node: ts.MethodDeclaration): void;
+    visitPropertyDeclaration(node: ts.PropertyDeclaration): void;
+    visitSemicolonClassElement(node: ts.SemicolonClassElement): void;
+    visitSetAccessor(node: ts.SetAccessorDeclaration): void;
+    static buildContract(ctx: AwstBuildContext, classDec: ts.ClassDeclaration): awst.ContractFragment;
+}