@algorandfoundation/puya-ts 1.0.0-alpha.10

package/awst_build/decorator-visitor.d.ts

@@ -0,0 +1,34 @@
+import type ts from 'typescript';
+import type { ARC4CreateOption, OnCompletionAction } from '../awst/models';
+import type { SourceLocation } from '../awst/source-location';
+import type { Constants } from '../constants';
+import { BaseVisitor } from './base-visitor';
+import type { AwstBuildContext } from './context/awst-build-context';
+export type Arc4AbiDecoratorData = {
+    type: typeof Constants.arc4AbiDecoratorName;
+    create: ARC4CreateOption;
+    ocas: OnCompletionAction[];
+    sourceLocation: SourceLocation;
+    readonly: boolean;
+    nameOverride: string | undefined;
+    defaultArguments: Record<string, {
+        type: 'constant';
+        value: string | boolean | bigint | Uint8Array;
+    } | {
+        type: 'member';
+        name: string;
+    }>;
+};
+export type Arc4BareDecoratorData = {
+    type: typeof Constants.arc4BareDecoratorName;
+    create: ARC4CreateOption;
+    ocas: OnCompletionAction[];
+    sourceLocation: SourceLocation;
+};
+export type DecoratorData = Arc4BareDecoratorData | Arc4AbiDecoratorData;
+export declare class DecoratorVisitor extends BaseVisitor {
+    private accept;
+    readonly result: DecoratorData;
+    constructor(context: AwstBuildContext, node: ts.Decorator);
+    static buildDecoratorData(context: AwstBuildContext, node: ts.Decorator): DecoratorData;
+}

package/awst_build/eb/arc4/arrays.d.ts

@@ -0,0 +1,31 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import { DynamicArrayType, StaticArrayType } from '../../ptypes/arc4-types';
+import type { InstanceBuilder } from '../index';
+import { FunctionBuilder, InstanceExpressionBuilder, NodeBuilder } from '../index';
+export declare class DynamicArrayConstructorBuilder extends NodeBuilder {
+    readonly ptype: import("../../ptypes").LibFunctionType;
+    newCall(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class StaticArrayConstructorBuilder extends NodeBuilder {
+    readonly ptype: import("../../ptypes").LibFunctionType;
+    newCall(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare abstract class ArrayExpressionBuilder<TArrayType extends DynamicArrayType | StaticArrayType> extends InstanceExpressionBuilder<TArrayType> {
+    iterate(sourceLocation: SourceLocation): Expression;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class DynamicArrayExpressionBuilder extends ArrayExpressionBuilder<DynamicArrayType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class StaticArrayExpressionBuilder extends ArrayExpressionBuilder<StaticArrayType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class ArrayAtFunctionBuilder extends FunctionBuilder {
+    private arrayBuilder;
+    constructor(arrayBuilder: ArrayExpressionBuilder<StaticArrayType | DynamicArrayType>);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/arc4/uint-n-constructor-builder.d.ts

@@ -0,0 +1,14 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import { UintNType } from '../../ptypes/arc4-types';
+import type { InstanceBuilder } from '../index';
+import { InstanceExpressionBuilder, NodeBuilder } from '../index';
+export declare class UintNConstructorBuilder extends NodeBuilder {
+    get ptype(): undefined;
+    newCall(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class UintNExpressionBuilder extends InstanceExpressionBuilder<UintNType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/arc4-bare-method-decorator-builder.d.ts

@@ -0,0 +1,19 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { DecoratorData } from '../decorator-visitor';
+import type { PType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { NodeBuilder } from './index';
+export declare class Arc4BareMethodDecoratorBuilder extends NodeBuilder {
+    get ptype(): PType;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class Arc4AbiMethodDecoratorBuilder extends NodeBuilder {
+    get ptype(): PType;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class DecoratorDataBuilder extends NodeBuilder {
+    private readonly data;
+    get ptype(): PType | undefined;
+    constructor(sourceLocation: SourceLocation, data: DecoratorData);
+    resolveDecoratorData(): DecoratorData;
+}

package/awst_build/eb/assert-function-builder.d.ts

@@ -0,0 +1,10 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { FunctionBuilder } from './index';
+export declare class AssertFunctionBuilder extends FunctionBuilder {
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class ErrFunctionBuilder extends FunctionBuilder {
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}

package/awst_build/eb/assert-match-function-builder.d.ts

@@ -0,0 +1,8 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { NodeBuilder } from './index';
+export declare class AssertMatchFunctionBuilder extends NodeBuilder {
+    readonly ptype: import("../ptypes").LibFunctionType;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/biguint-expression-builder.d.ts

@@ -0,0 +1,21 @@
+import type { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { InstanceType, PType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { BuilderBinaryOp, BuilderComparisonOp, BuilderUnaryOp, FunctionBuilder, InstanceExpressionBuilder } from './index';
+export declare class BigUintFunctionBuilder extends FunctionBuilder {
+    readonly ptype: import("../ptypes").LibFunctionType;
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class BigUintExpressionBuilder extends InstanceExpressionBuilder<InstanceType> {
+    constructor(expr: Expression);
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): Expression;
+    prefixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    postfixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    augmentedAssignment(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    assign(other: InstanceBuilder, sourceLocation: SourceLocation): InstanceBuilder;
+    toBytes(sourceLocation: SourceLocation): awst.Expression;
+}

package/awst_build/eb/boolean-expression-builder.d.ts

@@ -0,0 +1,15 @@
+import type { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { InstanceType, PType } from '../ptypes';
+import type { InstanceBuilder, NodeBuilder } from './index';
+import { BuilderComparisonOp, FunctionBuilder, InstanceExpressionBuilder } from './index';
+export declare class BooleanFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BooleanExpressionBuilder extends InstanceExpressionBuilder<InstanceType> {
+    constructor(expr: Expression);
+    boolEval(sourceLocation: SourceLocation, negate: boolean): awst.Expression;
+    toBytes(sourceLocation: SourceLocation): Expression;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+}

package/awst_build/eb/bytes-expression-builder.d.ts

@@ -0,0 +1,44 @@
+import type { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { InstanceType, PType } from '../ptypes';
+import type { BuilderComparisonOp, InstanceBuilder, NodeBuilder } from './index';
+import { BuilderUnaryOp, FunctionBuilder, InstanceExpressionBuilder, ParameterlessFunctionBuilder } from './index';
+export declare class BytesFunctionBuilder extends FunctionBuilder {
+    readonly ptype: import("../ptypes").LibFunctionType;
+    taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, sourceLocation: SourceLocation): InstanceBuilder;
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BytesExpressionBuilder extends InstanceExpressionBuilder<InstanceType> {
+    constructor(expr: Expression);
+    prefixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    boolEval(sourceLocation: SourceLocation, negate: boolean): awst.Expression;
+    toBytes(): awst.Expression;
+    toString(sourceLocation: SourceLocation): Expression;
+}
+export declare class ConcatExpressionBuilder extends FunctionBuilder {
+    private expr;
+    constructor(expr: awst.Expression);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): BytesExpressionBuilder;
+}
+export declare class BytesInvertBuilder extends ParameterlessFunctionBuilder {
+    private expr;
+    constructor(expr: awst.Expression);
+}
+export declare class BytesSliceBuilder extends FunctionBuilder {
+    private expr;
+    constructor(expr: awst.Expression);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): BytesExpressionBuilder;
+}
+export declare class ToStringBuilder extends ParameterlessFunctionBuilder {
+    private expr;
+    constructor(expr: awst.Expression);
+}
+export declare class BytesAtBuilder extends FunctionBuilder {
+    private expr;
+    constructor(expr: awst.Expression);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder<PType>;
+}

package/awst_build/eb/contract-builder.d.ts

@@ -0,0 +1,19 @@
+import type { Expression, LValue } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { AwstBuildContext } from '../context/awst-build-context';
+import type { ContractClassPType, PType } from '../ptypes';
+import type { NodeBuilder } from './index';
+import { InstanceBuilder } from './index';
+export declare class ContractThisBuilder extends InstanceBuilder<ContractClassPType> {
+    #private;
+    private context;
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    constructor(ptype: ContractClassPType, sourceLocation: SourceLocation, context: AwstBuildContext);
+    get ptype(): ContractClassPType;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class ContractSuperBuilder extends ContractThisBuilder {
+    constructor(ptype: ContractClassPType, sourceLocation: SourceLocation, context: AwstBuildContext);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/ensure-budget.d.ts

@@ -0,0 +1,8 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { InstanceBuilder, NodeBuilder } from './index';
+import { FunctionBuilder } from './index';
+export declare class EnsureBudgetFunctionBuilder extends FunctionBuilder {
+    readonly ptype: import("../ptypes").LibFunctionType;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/folding.d.ts

@@ -0,0 +1,5 @@
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import { BuilderBinaryOp, BuilderComparisonOp } from './index';
+export declare function foldBinaryOp(left: bigint, right: bigint, op: BuilderBinaryOp, sourceLocation: SourceLocation): bigint;
+export declare function foldComparisonOp(left: bigint, right: bigint, op: BuilderComparisonOp, sourceLocation: SourceLocation): Expression;

package/awst_build/eb/free-subroutine-expression-builder.d.ts

@@ -0,0 +1,22 @@
+import type { InstanceMethodTarget, InstanceSuperMethodTarget, SubroutineID } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { ContractClassPType, PType } from '../ptypes';
+import { FunctionPType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { FunctionBuilder } from './index';
+declare abstract class SubroutineExpressionBuilder extends FunctionBuilder {
+    readonly ptype: FunctionPType;
+    protected readonly target: SubroutineID | InstanceMethodTarget | InstanceSuperMethodTarget;
+    protected constructor(sourceLocation: SourceLocation, ptype: FunctionPType, target: SubroutineID | InstanceMethodTarget | InstanceSuperMethodTarget);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class ContractMethodExpressionBuilder extends SubroutineExpressionBuilder {
+    constructor(sourceLocation: SourceLocation, ptype: FunctionPType);
+}
+export declare class BaseContractMethodExpressionBuilder extends SubroutineExpressionBuilder {
+    constructor(sourceLocation: SourceLocation, ptype: FunctionPType, baseContractPType: ContractClassPType);
+}
+export declare class FreeSubroutineExpressionBuilder extends SubroutineExpressionBuilder {
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+}
+export {};

package/awst_build/eb/index.d.ts

@@ -0,0 +1,90 @@
+import { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType, PTypeOrClass } from '../ptypes';
+export declare enum BuilderComparisonOp {
+    eq = "===",
+    ne = "!==",
+    lt = "<",
+    lte = "<=",
+    gt = ">",
+    gte = ">="
+}
+export declare enum BuilderUnaryOp {
+    inc = "++",
+    dec = "--",
+    bit_inv = "~",
+    neg = "-",
+    pos = "+"
+}
+export declare enum BuilderBinaryOp {
+    add = "+",
+    sub = "-",
+    mult = "*",
+    div = "/",
+    mod = "%",
+    pow = "**",
+    matMult = "@",
+    lshift = "<<",
+    rshift = ">>",
+    bitOr = "|",
+    bitXor = "^",
+    bitAnd = "&",
+    /**
+     * Eval left, return right
+     * let y = 2
+     * // x == 4
+     * const x = (y * 3, y - 2)
+     */
+    comma = ","
+}
+export declare abstract class NodeBuilder {
+    readonly sourceLocation: SourceLocation;
+    constructor(sourceLocation: SourceLocation);
+    abstract readonly ptype: PType | undefined;
+    get typeDescription(): string;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+    newCall(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+    taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, sourceLocation: SourceLocation): InstanceBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    indexAccess(index: InstanceBuilder, sourceLocation: SourceLocation): NodeBuilder;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): awst.Expression;
+}
+export declare abstract class InstanceBuilder<TPType extends PType = PType> extends NodeBuilder {
+    constructor(sourceLocation: SourceLocation);
+    abstract get ptype(): TPType;
+    abstract resolve(): awst.Expression;
+    abstract resolveLValue(): awst.LValue;
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+    singleEvaluation(): InstanceBuilder;
+    toBytes(sourceLocation: SourceLocation): awst.Expression;
+    toString(sourceLocation: SourceLocation): awst.Expression;
+    prefixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    postfixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    iterate(sourceLocation: SourceLocation): awst.Expression;
+    augmentedAssignment(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    hasProperty(_name: string): boolean;
+}
+export declare abstract class FunctionBuilder extends NodeBuilder {
+    readonly ptype: PType | undefined;
+    constructor(location: SourceLocation);
+    abstract call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare abstract class ParameterlessFunctionBuilder extends FunctionBuilder {
+    private readonly expression;
+    private readonly definition;
+    constructor(expression: Expression, definition: (expr: Expression, sourceLocation: SourceLocation) => NodeBuilder);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare abstract class InstanceExpressionBuilder<TPType extends PType> extends InstanceBuilder<PType> {
+    #private;
+    protected _expr: awst.Expression;
+    get ptype(): TPType;
+    constructor(_expr: awst.Expression, ptype: TPType);
+    resolve(): awst.Expression;
+    resolveLValue(): awst.LValue;
+}
+export declare function requireLValue(expr: awst.Expression): awst.LValue;

package/awst_build/eb/intrinsic-enum-builder.d.ts

@@ -0,0 +1,9 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import { IntrinsicEnumType } from '../ptypes';
+import { NodeBuilder } from './index';
+export declare class IntrinsicEnumBuilder extends NodeBuilder {
+    readonly ptype: IntrinsicEnumType;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/iterable-iterator-expression-builder.d.ts

@@ -0,0 +1,10 @@
+import type { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import { IterableIteratorType, type PType } from '../ptypes';
+import { InstanceExpressionBuilder } from './index';
+export declare class IterableIteratorExpressionBuilder extends InstanceExpressionBuilder<IterableIteratorType> {
+    resolve(): awst.Expression;
+    constructor(expr: Expression, ptype: PType);
+    iterate(sourceLocation: SourceLocation): Expression;
+}

package/awst_build/eb/literal/array-literal-expression-builder.d.ts

@@ -0,0 +1,18 @@
+import type { Expression, LValue } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PTypeOrClass } from '../../ptypes';
+import { ArrayLiteralPType } from '../../ptypes';
+import type { NodeBuilder } from '../index';
+import { InstanceBuilder } from '../index';
+export declare class ArrayLiteralExpressionBuilder extends InstanceBuilder {
+    private readonly items;
+    readonly ptype: ArrayLiteralPType;
+    constructor(sourceLocation: SourceLocation, items: InstanceBuilder[]);
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    singleEvaluation(): InstanceBuilder;
+    indexAccess(index: InstanceBuilder, sourceLocation: SourceLocation): NodeBuilder;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+    getItemBuilders(): InstanceBuilder[];
+}

package/awst_build/eb/literal/big-int-literal-expression-builder.d.ts

@@ -0,0 +1,17 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PTypeOrClass } from '../../ptypes';
+import { TransientType } from '../../ptypes';
+import type { BuilderBinaryOp, BuilderComparisonOp, InstanceBuilder } from '../index';
+import { LiteralExpressionBuilder } from '../literal-expression-builder';
+export declare class BigIntLiteralExpressionBuilder extends LiteralExpressionBuilder {
+    readonly value: bigint;
+    readonly ptype: TransientType;
+    singleEvaluation(): InstanceBuilder;
+    constructor(value: bigint, ptype: TransientType, location: SourceLocation);
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): Expression;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+}

package/awst_build/eb/literal/conditional-expression-builder.d.ts

@@ -0,0 +1,22 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType, PTypeOrClass } from '../../ptypes';
+import type { InstanceBuilder } from '../index';
+import { LiteralExpressionBuilder } from '../literal-expression-builder';
+export declare class ConditionalExpressionBuilder extends LiteralExpressionBuilder {
+    private readonly _ptype;
+    private readonly whenTrue;
+    private readonly whenFalse;
+    private readonly condition;
+    get ptype(): PType;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): Expression;
+    constructor({ condition, ptype, whenFalse, whenTrue, sourceLocation, }: {
+        ptype: PType;
+        condition: Expression;
+        whenTrue: InstanceBuilder;
+        whenFalse: InstanceBuilder;
+        sourceLocation: SourceLocation;
+    });
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+}

package/awst_build/eb/literal/object-expression-builder.d.ts

@@ -0,0 +1,13 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PTypeOrClass } from '../../ptypes';
+import { ObjectPType, type PType } from '../../ptypes';
+import type { InstanceBuilder } from '../index';
+import { InstanceExpressionBuilder, type NodeBuilder } from '../index';
+export declare class ObjectExpressionBuilder extends InstanceExpressionBuilder<ObjectPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    hasProperty(name: string): boolean;
+    resolvableToPType(ptype: PTypeOrClass): ptype is ObjectPType;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+}

package/awst_build/eb/literal/object-literal-expression-builder.d.ts

@@ -0,0 +1,28 @@
+import type { Expression, LValue } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PTypeOrClass } from '../../ptypes';
+import { ObjectPType } from '../../ptypes';
+import type { InstanceBuilder } from '../index';
+import { LiteralExpressionBuilder } from '../literal-expression-builder';
+export type ObjectLiteralParts = {
+    type: 'properties';
+    properties: Record<string, InstanceBuilder>;
+} | {
+    type: 'spread-object';
+    obj: InstanceBuilder;
+};
+export declare class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
+    private readonly parts;
+    private readonly generateDiscardedVarName;
+    readonly _ptype: ObjectPType;
+    get ptype(): ObjectPType;
+    constructor(sourceLocation: SourceLocation, ptype: ObjectPType, parts: ObjectLiteralParts[], generateDiscardedVarName: () => string);
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    memberAccess(name: string, sourceLocation: SourceLocation): InstanceBuilder;
+    hasProperty(name: string): boolean;
+    private toTuple;
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+    assign(other: InstanceBuilder, sourceLocation: SourceLocation): InstanceBuilder;
+}

package/awst_build/eb/literal-expression-builder.d.ts

@@ -0,0 +1,27 @@
+import type { awst } from '../../awst';
+import type { Expression, LValue } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType, PTypeOrClass } from '../ptypes';
+import type { BuilderBinaryOp, BuilderComparisonOp, BuilderUnaryOp, NodeBuilder } from './index';
+import { InstanceBuilder } from './index';
+export declare abstract class LiteralExpressionBuilder extends InstanceBuilder {
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    abstract resolvableToPType(ptype: PTypeOrClass): boolean;
+    abstract resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+    private throwInvalidExpression;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    assign(other: InstanceBuilder, sourceLocation: SourceLocation): InstanceBuilder;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+    taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, sourceLocation: SourceLocation): InstanceBuilder;
+    indexAccess(index: InstanceBuilder, sourceLocation: SourceLocation): NodeBuilder;
+    singleEvaluation(): InstanceBuilder;
+    toBytes(sourceLocation: SourceLocation): awst.Expression;
+    prefixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    postfixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    iterate(sourceLocation: SourceLocation): awst.Expression;
+    augmentedAssignment(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    hasProperty(_name: string): boolean;
+}

package/awst_build/eb/log-function-builder.d.ts

@@ -0,0 +1,7 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { FunctionBuilder } from './index';
+export declare class LogFunctionBuilder extends FunctionBuilder {
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}

package/awst_build/eb/namespace-builder.d.ts

@@ -0,0 +1,9 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import { NodeBuilder } from './index';
+export declare class NamespaceBuilder extends NodeBuilder {
+    private readonly _ptype;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+    get ptype(): PType;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/native-array-expression-builder.d.ts

@@ -0,0 +1,8 @@
+import type { Expression, LValue } from '../../awst/nodes';
+import type { PType } from '../ptypes';
+import { ArrayPType } from '../ptypes';
+import { InstanceExpressionBuilder } from './index';
+export declare class NativeArrayExpressionBuilder extends InstanceExpressionBuilder<ArrayPType> {
+    resolveLValue(): LValue;
+    constructor(expr: Expression, ptype: PType);
+}

package/awst_build/eb/omitted-expression-builder.d.ts

@@ -0,0 +1,9 @@
+import type { Expression, LValue } from '../../awst/nodes';
+import type { PType, PTypeOrClass } from '../ptypes';
+import { InstanceBuilder } from './index';
+export declare class OmittedExpressionBuilder extends InstanceBuilder {
+    get ptype(): PType;
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+}

package/awst_build/eb/op-module-builder.d.ts

@@ -0,0 +1,25 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { IntrinsicOpMapping } from '../op-metadata';
+import type { PType } from '../ptypes';
+import { IntrinsicFunctionGroupType, IntrinsicFunctionType } from '../ptypes';
+import type { InstanceBuilder } from './index';
+import { FunctionBuilder, NodeBuilder } from './index';
+export declare class IntrinsicOpGroupBuilder extends NodeBuilder {
+    private opGrouping;
+    readonly ptype: IntrinsicFunctionGroupType;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+declare abstract class IntrinsicOpBuilderBase extends FunctionBuilder {
+    private opMapping;
+    protected constructor(sourceLocation: SourceLocation, opMapping: IntrinsicOpMapping);
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class FreeIntrinsicOpBuilder extends IntrinsicOpBuilderBase {
+    readonly ptype: IntrinsicFunctionType;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+}
+export declare class GroupedIntrinsicOpBuilder extends IntrinsicOpBuilderBase {
+    constructor(sourceLocation: SourceLocation, opMapping: IntrinsicOpMapping);
+}
+export {};

package/awst_build/eb/reference/account.d.ts

@@ -0,0 +1,15 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import type { BuilderComparisonOp, InstanceBuilder, NodeBuilder } from '../index';
+import { FunctionBuilder } from '../index';
+import { ReferenceTypeExpressionBuilder } from './base';
+export declare class AccountFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class AccountExpressionBuilder extends ReferenceTypeExpressionBuilder {
+    constructor(expr: Expression);
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    toBytes(sourceLocation: SourceLocation): Expression;
+}

package/awst_build/eb/reference/application.d.ts

@@ -0,0 +1,12 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import type { InstanceBuilder, NodeBuilder } from '../index';
+import { FunctionBuilder } from '../index';
+import { Uint64BackedReferenceTypeExpressionBuilder } from './base';
+export declare class ApplicationFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class ApplicationExpressionBuilder extends Uint64BackedReferenceTypeExpressionBuilder {
+    constructor(expr: Expression);
+}

package/awst_build/eb/reference/asset.d.ts

@@ -0,0 +1,13 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import type { InstanceBuilder, NodeBuilder } from '../index';
+import { FunctionBuilder } from '../index';
+import { Uint64BackedReferenceTypeExpressionBuilder } from './base';
+export declare class AssetFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class AssetExpressionBuilder extends Uint64BackedReferenceTypeExpressionBuilder {
+    constructor(expr: Expression);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}